github.com/makyo/juju@v0.0.0-20160425123129-2608902037e9/state/resources_mongo_test.go (about)

     1  // Copyright 2016 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package state
     5  
     6  import (
     7  	"strings"
     8  	"time"
     9  
    10  	"github.com/juju/testing"
    11  	jc "github.com/juju/testing/checkers"
    12  	gc "gopkg.in/check.v1"
    13  	charmresource "gopkg.in/juju/charm.v6-unstable/resource"
    14  
    15  	"github.com/juju/juju/resource"
    16  )
    17  
    18  type ResourcesMongoSuite struct {
    19  	testing.IsolationSuite
    20  }
    21  
    22  var _ = gc.Suite(&ResourcesMongoSuite{})
    23  
    24  func (s *ResourcesMongoSuite) TestResource2DocUploadFull(c *gc.C) {
    25  	content := "some data\n..."
    26  	fp, err := charmresource.GenerateFingerprint(strings.NewReader(content))
    27  	c.Assert(err, jc.ErrorIsNil)
    28  	now := time.Now().UTC()
    29  
    30  	serviceID := "a-service"
    31  	docID := serviceResourceID("spam")
    32  	res := resource.Resource{
    33  		Resource: charmresource.Resource{
    34  			Meta: charmresource.Meta{
    35  				Name:        "spam",
    36  				Type:        charmresource.TypeFile,
    37  				Path:        "spam.tgz",
    38  				Description: "you need this!",
    39  			},
    40  			Origin:      charmresource.OriginUpload,
    41  			Revision:    0,
    42  			Fingerprint: fp,
    43  			Size:        int64(len(content)),
    44  		},
    45  		ID:        serviceID + "/spam",
    46  		PendingID: "some-unique-ID",
    47  		ServiceID: serviceID,
    48  		Username:  "a-user",
    49  		Timestamp: now,
    50  	}
    51  	doc := resource2doc(docID, storedResource{
    52  		Resource:    res,
    53  		storagePath: "service-a-service/resources/spam",
    54  	})
    55  
    56  	c.Check(doc, jc.DeepEquals, &resourceDoc{
    57  		DocID:     docID,
    58  		ID:        res.ID,
    59  		PendingID: "some-unique-ID",
    60  		ServiceID: serviceID,
    61  
    62  		Name:        "spam",
    63  		Type:        "file",
    64  		Path:        "spam.tgz",
    65  		Description: "you need this!",
    66  
    67  		Origin:      "upload",
    68  		Revision:    0,
    69  		Fingerprint: fp.Bytes(),
    70  		Size:        int64(len(content)),
    71  
    72  		Username:  "a-user",
    73  		Timestamp: now,
    74  
    75  		StoragePath: "service-a-service/resources/spam",
    76  	})
    77  }
    78  
    79  func (s *ResourcesMongoSuite) TestResource2DocUploadBasic(c *gc.C) {
    80  	content := "some data\n..."
    81  	fp, err := charmresource.GenerateFingerprint(strings.NewReader(content))
    82  	c.Assert(err, jc.ErrorIsNil)
    83  	now := time.Now().UTC()
    84  
    85  	serviceID := "a-service"
    86  	docID := serviceResourceID("spam")
    87  	res := resource.Resource{
    88  		Resource: charmresource.Resource{
    89  			Meta: charmresource.Meta{
    90  				Name: "spam",
    91  				Type: charmresource.TypeFile,
    92  				Path: "spam.tgz",
    93  			},
    94  			Origin:      charmresource.OriginUpload,
    95  			Fingerprint: fp,
    96  			Size:        int64(len(content)),
    97  		},
    98  		ID:        serviceID + "/spam",
    99  		ServiceID: serviceID,
   100  		Username:  "a-user",
   101  		Timestamp: now,
   102  	}
   103  	doc := resource2doc(docID, storedResource{
   104  		Resource:    res,
   105  		storagePath: "service-a-service/resources/spam",
   106  	})
   107  
   108  	c.Check(doc, jc.DeepEquals, &resourceDoc{
   109  		DocID:     docID,
   110  		ID:        res.ID,
   111  		ServiceID: serviceID,
   112  
   113  		Name: "spam",
   114  		Type: "file",
   115  		Path: "spam.tgz",
   116  
   117  		Origin:      "upload",
   118  		Fingerprint: fp.Bytes(),
   119  		Size:        int64(len(content)),
   120  
   121  		Username:  "a-user",
   122  		Timestamp: now,
   123  
   124  		StoragePath: "service-a-service/resources/spam",
   125  	})
   126  }
   127  
   128  func (s *ResourcesMongoSuite) TestResource2DocUploadPending(c *gc.C) {
   129  	content := "some data\n..."
   130  	fp, err := charmresource.GenerateFingerprint(strings.NewReader(content))
   131  	c.Assert(err, jc.ErrorIsNil)
   132  	now := time.Now().UTC()
   133  
   134  	serviceID := "a-service"
   135  	docID := pendingResourceID("spam", "some-unique-ID-001")
   136  	res := resource.Resource{
   137  		Resource: charmresource.Resource{
   138  			Meta: charmresource.Meta{
   139  				Name: "spam",
   140  				Type: charmresource.TypeFile,
   141  				Path: "spam.tgz",
   142  			},
   143  			Origin:      charmresource.OriginUpload,
   144  			Fingerprint: fp,
   145  			Size:        int64(len(content)),
   146  		},
   147  		ID:        serviceID + "/spam",
   148  		PendingID: "some-unique-ID-001",
   149  		ServiceID: serviceID,
   150  		Username:  "a-user",
   151  		Timestamp: now,
   152  	}
   153  	doc := resource2doc(docID, storedResource{
   154  		Resource:    res,
   155  		storagePath: "service-a-service/resources/spam",
   156  	})
   157  
   158  	c.Check(doc, jc.DeepEquals, &resourceDoc{
   159  		DocID:     docID,
   160  		ID:        res.ID,
   161  		PendingID: "some-unique-ID-001",
   162  		ServiceID: serviceID,
   163  
   164  		Name: "spam",
   165  		Type: "file",
   166  		Path: "spam.tgz",
   167  
   168  		Origin:      "upload",
   169  		Fingerprint: fp.Bytes(),
   170  		Size:        int64(len(content)),
   171  
   172  		Username:  "a-user",
   173  		Timestamp: now,
   174  
   175  		StoragePath: "service-a-service/resources/spam",
   176  	})
   177  }
   178  
   179  func (s *ResourcesMongoSuite) TestDoc2Resource(c *gc.C) {
   180  	serviceID := "a-service"
   181  	docID := pendingResourceID("spam", "some-unique-ID-001")
   182  	content := "some data\n..."
   183  	fp, err := charmresource.GenerateFingerprint(strings.NewReader(content))
   184  	c.Assert(err, jc.ErrorIsNil)
   185  	now := time.Now().UTC()
   186  
   187  	res, err := doc2resource(resourceDoc{
   188  		DocID:     docID,
   189  		ID:        "a-service/spam",
   190  		PendingID: "some-unique-ID-001",
   191  		ServiceID: serviceID,
   192  
   193  		Name: "spam",
   194  		Type: "file",
   195  		Path: "spam.tgz",
   196  
   197  		Origin:      "upload",
   198  		Fingerprint: fp.Bytes(),
   199  		Size:        int64(len(content)),
   200  
   201  		Username:  "a-user",
   202  		Timestamp: now,
   203  
   204  		StoragePath: "service-a-service/resources/spam-some-unique-ID-001",
   205  	})
   206  	c.Assert(err, jc.ErrorIsNil)
   207  
   208  	c.Check(res, jc.DeepEquals, storedResource{
   209  		Resource: resource.Resource{
   210  			Resource: charmresource.Resource{
   211  				Meta: charmresource.Meta{
   212  					Name: "spam",
   213  					Type: charmresource.TypeFile,
   214  					Path: "spam.tgz",
   215  				},
   216  				Origin:      charmresource.OriginUpload,
   217  				Fingerprint: fp,
   218  				Size:        int64(len(content)),
   219  			},
   220  			ID:        "a-service/spam",
   221  			PendingID: "some-unique-ID-001",
   222  			ServiceID: serviceID,
   223  			Username:  "a-user",
   224  			Timestamp: now,
   225  		},
   226  		storagePath: "service-a-service/resources/spam-some-unique-ID-001",
   227  	})
   228  }
   229  
   230  func (s *ResourcesMongoSuite) TestDoc2BasicResourceUploadFull(c *gc.C) {
   231  	serviceID := "a-service"
   232  	docID := pendingResourceID("spam", "some-unique-ID-001")
   233  	content := "some data\n..."
   234  	fp, err := charmresource.GenerateFingerprint(strings.NewReader(content))
   235  	c.Assert(err, jc.ErrorIsNil)
   236  	now := time.Now().UTC()
   237  
   238  	res, err := doc2basicResource(resourceDoc{
   239  		DocID:     docID,
   240  		ID:        "a-service/spam",
   241  		ServiceID: serviceID,
   242  		PendingID: "some-unique-ID-001",
   243  
   244  		Name:        "spam",
   245  		Type:        "file",
   246  		Path:        "spam.tgz",
   247  		Description: "you need this!",
   248  
   249  		Origin:      "upload",
   250  		Revision:    0,
   251  		Fingerprint: fp.Bytes(),
   252  		Size:        int64(len(content)),
   253  
   254  		Username:  "a-user",
   255  		Timestamp: now,
   256  
   257  		StoragePath: "service-a-service/resources/spam",
   258  	})
   259  	c.Assert(err, jc.ErrorIsNil)
   260  
   261  	c.Check(res, jc.DeepEquals, resource.Resource{
   262  		Resource: charmresource.Resource{
   263  			Meta: charmresource.Meta{
   264  				Name:        "spam",
   265  				Type:        charmresource.TypeFile,
   266  				Path:        "spam.tgz",
   267  				Description: "you need this!",
   268  			},
   269  			Origin:      charmresource.OriginUpload,
   270  			Revision:    0,
   271  			Fingerprint: fp,
   272  			Size:        int64(len(content)),
   273  		},
   274  		ID:        "a-service/spam",
   275  		PendingID: "some-unique-ID-001",
   276  		ServiceID: serviceID,
   277  		Username:  "a-user",
   278  		Timestamp: now,
   279  	})
   280  }
   281  
   282  func (s *ResourcesMongoSuite) TestDoc2BasicResourceUploadBasic(c *gc.C) {
   283  	serviceID := "a-service"
   284  	docID := serviceResourceID("spam")
   285  	content := "some data\n..."
   286  	fp, err := charmresource.GenerateFingerprint(strings.NewReader(content))
   287  	c.Assert(err, jc.ErrorIsNil)
   288  	now := time.Now().UTC()
   289  
   290  	res, err := doc2basicResource(resourceDoc{
   291  		DocID:     docID,
   292  		ID:        "a-service/spam",
   293  		ServiceID: serviceID,
   294  
   295  		Name: "spam",
   296  		Type: "file",
   297  		Path: "spam.tgz",
   298  
   299  		Origin:      "upload",
   300  		Fingerprint: fp.Bytes(),
   301  		Size:        int64(len(content)),
   302  
   303  		Username:  "a-user",
   304  		Timestamp: now,
   305  
   306  		StoragePath: "service-a-service/resources/spam",
   307  	})
   308  	c.Assert(err, jc.ErrorIsNil)
   309  
   310  	c.Check(res, jc.DeepEquals, resource.Resource{
   311  		Resource: charmresource.Resource{
   312  			Meta: charmresource.Meta{
   313  				Name: "spam",
   314  				Type: charmresource.TypeFile,
   315  				Path: "spam.tgz",
   316  			},
   317  			Origin:      charmresource.OriginUpload,
   318  			Fingerprint: fp,
   319  			Size:        int64(len(content)),
   320  		},
   321  		ID:        "a-service/spam",
   322  		ServiceID: serviceID,
   323  		Username:  "a-user",
   324  		Timestamp: now,
   325  	})
   326  }
   327  
   328  func (s *ResourcesMongoSuite) TestResource2DocCharmstoreFull(c *gc.C) {
   329  	content := "some data\n..."
   330  	fp, err := charmresource.GenerateFingerprint(strings.NewReader(content))
   331  	c.Assert(err, jc.ErrorIsNil)
   332  	now := time.Now().UTC()
   333  
   334  	serviceID := "a-service"
   335  	docID := serviceResourceID("spam")
   336  	res := resource.Resource{
   337  		Resource: charmresource.Resource{
   338  			Meta: charmresource.Meta{
   339  				Name:        "spam",
   340  				Type:        charmresource.TypeFile,
   341  				Path:        "spam.tgz",
   342  				Description: "you need this!",
   343  			},
   344  			Origin:      charmresource.OriginStore,
   345  			Revision:    5,
   346  			Fingerprint: fp,
   347  			Size:        int64(len(content)),
   348  		},
   349  		ID:        "a-service/spam",
   350  		PendingID: "some-unique-ID",
   351  		ServiceID: serviceID,
   352  		Username:  "a-user",
   353  		Timestamp: now,
   354  	}
   355  	doc := resource2doc(docID, storedResource{
   356  		Resource:    res,
   357  		storagePath: "service-a-service/resources/spam",
   358  	})
   359  
   360  	c.Check(doc, jc.DeepEquals, &resourceDoc{
   361  		DocID:     docID,
   362  		ID:        res.ID,
   363  		PendingID: "some-unique-ID",
   364  
   365  		ServiceID: serviceID,
   366  
   367  		Name:        "spam",
   368  		Type:        "file",
   369  		Path:        "spam.tgz",
   370  		Description: "you need this!",
   371  
   372  		Origin:      "store",
   373  		Revision:    5,
   374  		Fingerprint: fp.Bytes(),
   375  		Size:        int64(len(content)),
   376  
   377  		Username:  "a-user",
   378  		Timestamp: now,
   379  
   380  		StoragePath: "service-a-service/resources/spam",
   381  	})
   382  }
   383  
   384  func (s *ResourcesMongoSuite) TestDoc2BasicResourceCharmstoreFull(c *gc.C) {
   385  	serviceID := "a-service"
   386  	docID := serviceResourceID("spam")
   387  	content := "some data\n..."
   388  	fp, err := charmresource.GenerateFingerprint(strings.NewReader(content))
   389  	c.Assert(err, jc.ErrorIsNil)
   390  	now := time.Now().UTC()
   391  
   392  	res, err := doc2basicResource(resourceDoc{
   393  		DocID:     docID,
   394  		ID:        "a-service/spam",
   395  		PendingID: "some-unique-ID",
   396  
   397  		ServiceID: serviceID,
   398  
   399  		Name:        "spam",
   400  		Type:        "file",
   401  		Path:        "spam.tgz",
   402  		Description: "you need this!",
   403  
   404  		Origin:      "store",
   405  		Revision:    5,
   406  		Fingerprint: fp.Bytes(),
   407  		Size:        int64(len(content)),
   408  
   409  		Username:  "a-user",
   410  		Timestamp: now,
   411  
   412  		StoragePath: "service-a-service/resources/spam",
   413  	})
   414  	c.Assert(err, jc.ErrorIsNil)
   415  
   416  	c.Check(res, jc.DeepEquals, resource.Resource{
   417  		Resource: charmresource.Resource{
   418  			Meta: charmresource.Meta{
   419  				Name:        "spam",
   420  				Type:        charmresource.TypeFile,
   421  				Path:        "spam.tgz",
   422  				Description: "you need this!",
   423  			},
   424  			Origin:      charmresource.OriginStore,
   425  			Revision:    5,
   426  			Fingerprint: fp,
   427  			Size:        int64(len(content)),
   428  		},
   429  		ID:        "a-service/spam",
   430  		PendingID: "some-unique-ID",
   431  		ServiceID: serviceID,
   432  		Username:  "a-user",
   433  		Timestamp: now,
   434  	})
   435  }
   436  
   437  func (s *ResourcesMongoSuite) TestDoc2BasicResourcePlaceholder(c *gc.C) {
   438  	serviceID := "a-service"
   439  	docID := serviceResourceID("spam")
   440  	res, err := doc2basicResource(resourceDoc{
   441  		DocID:     docID,
   442  		ID:        "a-service/spam",
   443  		ServiceID: serviceID,
   444  
   445  		Name: "spam",
   446  		Type: "file",
   447  		Path: "spam.tgz",
   448  
   449  		Origin: "upload",
   450  
   451  		StoragePath: "service-a-service/resources/spam",
   452  	})
   453  	c.Assert(err, jc.ErrorIsNil)
   454  
   455  	c.Check(res, jc.DeepEquals, resource.Resource{
   456  		Resource: charmresource.Resource{
   457  			Meta: charmresource.Meta{
   458  				Name: "spam",
   459  				Type: charmresource.TypeFile,
   460  				Path: "spam.tgz",
   461  			},
   462  			Origin: charmresource.OriginUpload,
   463  		},
   464  		ID:        "a-service/spam",
   465  		ServiceID: serviceID,
   466  	})
   467  }
   468  
   469  func (s *ResourcesMongoSuite) TestResource2DocLocalPlaceholder(c *gc.C) {
   470  	serviceID := "a-service"
   471  	docID := serviceResourceID("spam")
   472  	res := resource.Resource{
   473  		Resource: charmresource.Resource{
   474  			Meta: charmresource.Meta{
   475  				Name: "spam",
   476  				Type: charmresource.TypeFile,
   477  				Path: "spam.tgz",
   478  			},
   479  			Origin: charmresource.OriginUpload,
   480  		},
   481  		ID:        "a-service/spam",
   482  		ServiceID: serviceID,
   483  	}
   484  	doc := resource2doc(docID, storedResource{
   485  		Resource:    res,
   486  		storagePath: "service-a-service/resources/spam",
   487  	})
   488  
   489  	c.Check(doc, jc.DeepEquals, &resourceDoc{
   490  		DocID:     docID,
   491  		ID:        res.ID,
   492  		ServiceID: serviceID,
   493  
   494  		Name: "spam",
   495  		Type: "file",
   496  		Path: "spam.tgz",
   497  
   498  		Origin: "upload",
   499  
   500  		StoragePath: "service-a-service/resources/spam",
   501  	})
   502  }
   503  
   504  func (s *ResourcesMongoSuite) TestCharmStoreResource2DocFull(c *gc.C) {
   505  	content := "some data\n..."
   506  	fp, err := charmresource.GenerateFingerprint(strings.NewReader(content))
   507  	c.Assert(err, jc.ErrorIsNil)
   508  	now := time.Now().UTC()
   509  
   510  	serviceID := "a-service"
   511  	id := serviceID + "/spam"
   512  	docID := serviceResourceID("spam") + "#charmstore"
   513  	res := charmresource.Resource{
   514  		Meta: charmresource.Meta{
   515  			Name:        "spam",
   516  			Type:        charmresource.TypeFile,
   517  			Path:        "spam.tgz",
   518  			Description: "you need this!",
   519  		},
   520  		Origin:      charmresource.OriginStore,
   521  		Revision:    3,
   522  		Fingerprint: fp,
   523  		Size:        int64(len(content)),
   524  	}
   525  	doc := charmStoreResource2Doc(docID, charmStoreResource{
   526  		Resource:   res,
   527  		id:         id,
   528  		serviceID:  serviceID,
   529  		lastPolled: now,
   530  	})
   531  
   532  	c.Check(doc, jc.DeepEquals, &resourceDoc{
   533  		DocID:     docID,
   534  		ID:        id,
   535  		ServiceID: serviceID,
   536  
   537  		Name:        "spam",
   538  		Type:        "file",
   539  		Path:        "spam.tgz",
   540  		Description: "you need this!",
   541  
   542  		Origin:      "store",
   543  		Revision:    3,
   544  		Fingerprint: fp.Bytes(),
   545  		Size:        int64(len(content)),
   546  
   547  		LastPolled: now,
   548  	})
   549  }