github.com/niedbalski/juju@v0.0.0-20190215020005-8ff100488e47/resource/api/client/base_test.go (about)

     1  // Copyright 2015 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package client_test
     5  
     6  import (
     7  	"fmt"
     8  	"io"
     9  	"net/http"
    10  	"time"
    11  
    12  	"github.com/juju/errors"
    13  	"github.com/juju/testing"
    14  	jc "github.com/juju/testing/checkers"
    15  	gc "gopkg.in/check.v1"
    16  	"gopkg.in/juju/names.v2"
    17  
    18  	basetesting "github.com/juju/juju/api/base/testing"
    19  	"github.com/juju/juju/apiserver/params"
    20  	"github.com/juju/juju/resource"
    21  	"github.com/juju/juju/resource/resourcetesting"
    22  )
    23  
    24  type BaseSuite struct {
    25  	testing.IsolationSuite
    26  
    27  	stub     *testing.Stub
    28  	facade   *stubFacade
    29  	response *params.UploadResult
    30  }
    31  
    32  func (s *BaseSuite) SetUpTest(c *gc.C) {
    33  	s.IsolationSuite.SetUpTest(c)
    34  
    35  	s.stub = &testing.Stub{}
    36  	s.facade = newStubFacade(c, s.stub)
    37  	s.response = &params.UploadResult{}
    38  }
    39  
    40  func (s *BaseSuite) Do(req *http.Request, body io.ReadSeeker, resp interface{}) error {
    41  	s.stub.AddCall("Do", req, body, resp)
    42  	if err := s.stub.NextErr(); err != nil {
    43  		return errors.Trace(err)
    44  	}
    45  
    46  	result, ok := resp.(*params.UploadResult)
    47  	if !ok {
    48  		msg := fmt.Sprintf("bad response type %T, expected params.UploadResult", resp)
    49  		return errors.NewNotValid(nil, msg)
    50  	}
    51  
    52  	*result = *s.response
    53  	return nil
    54  }
    55  
    56  func newResourceResult(c *gc.C, applicationID string, names ...string) ([]resource.Resource, params.ResourcesResult) {
    57  	var resources []resource.Resource
    58  	var apiResult params.ResourcesResult
    59  	for _, name := range names {
    60  		data := name + "...spamspamspam"
    61  		res, apiRes := newResource(c, name, "a-user", data)
    62  		resources = append(resources, res)
    63  		apiResult.Resources = append(apiResult.Resources, apiRes)
    64  	}
    65  	return resources, apiResult
    66  }
    67  
    68  func newResource(c *gc.C, name, username, data string) (resource.Resource, params.Resource) {
    69  	opened := resourcetesting.NewResource(c, nil, name, "a-application", data)
    70  	res := opened.Resource
    71  	res.Revision = 1
    72  	res.Username = username
    73  	if username == "" {
    74  		// Note that resourcetesting.NewResource() returns a resources
    75  		// with a username and timestamp set. So if the username was
    76  		// "un-set" then we have to also unset the timestamp.
    77  		res.Timestamp = time.Time{}
    78  	}
    79  
    80  	apiRes := params.Resource{
    81  		CharmResource: params.CharmResource{
    82  			Name:        name,
    83  			Description: name + " description",
    84  			Type:        "file",
    85  			Path:        res.Path,
    86  			Origin:      "upload",
    87  			Revision:    1,
    88  			Fingerprint: res.Fingerprint.Bytes(),
    89  			Size:        res.Size,
    90  		},
    91  		ID:            res.ID,
    92  		ApplicationID: res.ApplicationID,
    93  		Username:      username,
    94  		Timestamp:     res.Timestamp,
    95  	}
    96  
    97  	return res, apiRes
    98  }
    99  
   100  type stubFacade struct {
   101  	basetesting.StubFacadeCaller
   102  
   103  	apiResults map[string]params.ResourcesResult
   104  	pendingIDs []string
   105  }
   106  
   107  func newStubFacade(c *gc.C, stub *testing.Stub) *stubFacade {
   108  	s := &stubFacade{
   109  		StubFacadeCaller: basetesting.StubFacadeCaller{
   110  			Stub: stub,
   111  		},
   112  		apiResults: make(map[string]params.ResourcesResult),
   113  	}
   114  
   115  	s.FacadeCallFn = func(_ string, args, response interface{}) error {
   116  		switch typedResponse := response.(type) {
   117  		case *params.ResourcesResults:
   118  			typedArgs, ok := args.(*params.ListResourcesArgs)
   119  			c.Assert(ok, jc.IsTrue)
   120  
   121  			for _, e := range typedArgs.Entities {
   122  				tag, err := names.ParseTag(e.Tag)
   123  				c.Assert(err, jc.ErrorIsNil)
   124  				service := tag.Id()
   125  
   126  				apiResult, ok := s.apiResults[service]
   127  				if !ok {
   128  					apiResult.Error = &params.Error{
   129  						Message: fmt.Sprintf("application %q not found", service),
   130  						Code:    params.CodeNotFound,
   131  					}
   132  				}
   133  				typedResponse.Results = append(typedResponse.Results, apiResult)
   134  			}
   135  		case *params.AddPendingResourcesResult:
   136  			typedResponse.PendingIDs = s.pendingIDs
   137  		default:
   138  			c.Errorf("bad type %T", response)
   139  		}
   140  		return nil
   141  	}
   142  
   143  	return s
   144  }
   145  
   146  func (s *stubFacade) Close() error {
   147  	s.Stub.AddCall("Close")
   148  	if err := s.Stub.NextErr(); err != nil {
   149  		return errors.Trace(err)
   150  	}
   151  
   152  	return nil
   153  }