func TestShopifyTransactions(t *testing.T) {
g := Goblin(t)
RegisterFailHandler(func(m string, _ ...int) { g.Fail(m) })
g.Describe("Transactions", func() {
var mockShopify *bogus.Bogus
g.BeforeEach(func() {
mockShopify = bogus.New()
mockShopify.Start()
})
g.AfterEach(func() {
mockShopify.Close()
})
g.Describe("Get All", func() {
g.It("should download a list of transactions", func() {
mockShopify.SetPayload([]byte(SampleTransactionsJson))
mockShopify.SetStatus(http.StatusOK)
host, port := mockShopify.HostPort()
s := &Shopify{fmt.Sprintf("http://%s:%s", host, port)}
c := &Credentials{"some-cart-id", "oauthom"}
transactions, err := s.GetTransactions("some-order-id", c, nil)
Expect(err).NotTo(HaveOccurred())
Expect(transactions).NotTo(BeNil())
Expect(len(transactions)).To(Equal(3))
t := transactions[0]
Expect(t).NotTo(BeNil())
Expect(t.Id).To(Equal(int64(179259969)))
Expect(t.OrderId).To(Equal(int64(450789469)))
Expect(t.Kind).To(Equal("refund"))
Expect(t.Gateway).To(Equal("bogus"))
Expect(t.Message).To(Equal(""))
Expect(t.CreatedAt).To(Equal("2005-08-05T12:59:12-04:00"))
Expect(t.Test).To(Equal(false))
Expect(t.Authorization).To(Equal("authorization-key"))
Expect(t.Status).To(Equal("success"))
Expect(t.Amount).To(Equal("209.00"))
Expect(t.Currency).To(Equal("USD"))
Expect(t.LocationId).To(Equal(""))
Expect(t.UserId).To(Equal(int64(0)))
Expect(t.ParentId).To(Equal(int64(0)))
Expect(t.DeviceId).To(Equal(int64(0)))
Expect(t.Receipt.Authorization).To(Equal(""))
Expect(t.Receipt.TestCase).To(Equal(false))
Expect(t.ErrorCode).To(Equal(""))
Expect(t.SourceName).To(Equal("web"))
})
})
})
}
func TestShopifyCustomers(t *testing.T) {
g := Goblin(t)
RegisterFailHandler(func(m string, _ ...int) { g.Fail(m) })
g.Describe("Customers", func() {
var mockShopify *bogus.Bogus
g.BeforeEach(func() {
mockShopify = bogus.New()
mockShopify.Start()
})
g.AfterEach(func() {
mockShopify.Close()
})
g.Describe("Get All", func() {
g.It("should download a list of customers", func() {
mockShopify.SetPayload([]byte(SampleCustomersJson))
mockShopify.SetStatus(http.StatusOK)
host, port := mockShopify.HostPort()
s := &Shopify{fmt.Sprintf("http://%s:%s", host, port)}
c := &Credentials{"some-cart-id", "oauthom"}
custs, err := s.GetCustomers(c, nil)
Expect(err).NotTo(HaveOccurred())
Expect(custs).NotTo(BeNil())
Expect(len(custs)).To(Equal(1))
Expect(custs[0].Id).To(Equal(int64(207119551)))
})
})
g.Describe("Count", func() {
g.It("should get an customers count", func() {
mockShopify.SetPayload([]byte(SampleCustomersCountJson))
mockShopify.SetStatus(http.StatusOK)
host, port := mockShopify.HostPort()
s := &Shopify{fmt.Sprintf("http://%s:%s", host, port)}
c := &Credentials{"some-cart-id", "oauthom"}
count, err := s.GetCustomersCount(c, nil)
Expect(err).NotTo(HaveOccurred())
Expect(count.Count).To(Equal(int64(33)))
})
})
})
}
func TestMediator(t *testing.T) {
g := Goblin(t)
RegisterFailHandler(func(m string, _ ...int) { g.Fail(m) })
g.Describe("Initialization", func() {
g.It("should return an error for blank values", func() {
_, err := New("", "", "", "", DefaultConnectionHeaders)
Expect(err).NotTo(Succeed())
_, err = New("host", "", "", "", DefaultConnectionHeaders)
Expect(err).NotTo(Succeed())
_, err = New("host", "port", "", "", DefaultConnectionHeaders)
Expect(err).NotTo(Succeed())
_, err = New("host", "port", "user", "", DefaultConnectionHeaders)
Expect(err).NotTo(Succeed())
_, err = New("host", "port", "user", "pass", DefaultConnectionHeaders)
Expect(err).NotTo(Succeed())
_, err = New("host", "port", "user", "pass", DefaultConnectionHeaders)
Expect(err).NotTo(Succeed())
})
})
g.Describe("Connecting & Subscribing", func() {
var server *bogus.Bogus
g.BeforeEach(func() {
server = bogus.New()
server.Start()
})
g.AfterEach(func() {
server.Close()
})
g.It("should connect to a broker", func() {
h, p := server.HostPort()
getStompConn = func(n net.Conn, h stompngo.Headers) (connectioner, error) {
return &mockstompngo.MockStompngo{}, nil
}
m, err := New(h, p, "user", "pass", DefaultConnectionHeaders)
Expect(err).NotTo(HaveOccurred())
Expect(m.netConn).NotTo(BeNil())
Expect(m.conn).NotTo(BeNil())
Expect(m.conn.Connected()).To(BeTrue())
})
g.It("should auto reconnect", func() {
h, p := server.HostPort()
hits := 0
hitsChan := make(chan int, 100)
mockstomp := mockstompngo.New()
getStompConn = func(n net.Conn, h stompngo.Headers) (connectioner, error) {
hits++
hitsChan <- hits
return mockstomp, nil
}
m, err := New(h, p, "user", "pass", DefaultConnectionHeaders)
Expect(err).NotTo(HaveOccurred())
m.reconnect = 50 * time.Millisecond
SetDefaultEventuallyPollingInterval(10 * time.Millisecond)
SetDefaultEventuallyTimeout(3 * time.Second)
Eventually(hitsChan).Should(Receive(Equal(3)))
Expect(mockstomp.DisconnectCalled).To(BeTrue())
})
g.It("should disconnect", func() {
h, p := server.HostPort()
mockstomp := mockstompngo.New()
getStompConn = func(n net.Conn, h stompngo.Headers) (connectioner, error) {
return mockstomp, nil
}
m, err := New(h, p, "user", "pass", DefaultConnectionHeaders)
Expect(err).NotTo(HaveOccurred())
err = m.Disconnect()
Expect(err).NotTo(HaveOccurred())
Expect(mockstomp.DisconnectCalled).To(BeTrue())
Expect(m.conn).To(BeNil())
})
g.It("should subscribe to a broker", func() {
h, p := server.HostPort()
mockstomp := mockstompngo.New()
getStompConn = func(n net.Conn, h stompngo.Headers) (connectioner, error) {
return mockstomp, nil
}
m, err := New(h, p, "user", "pass", DefaultConnectionHeaders)
err = m.Subscribe(DefaultSubscriptionHeaders)
Expect(err).NotTo(HaveOccurred())
Expect(mockstomp.SubscribeCalled).To(BeTrue())
})
})
g.Describe("Sending", func() {
var server *bogus.Bogus
mockstomp := mockstompngo.New()
getStompConn = func(n net.Conn, h stompngo.Headers) (connectioner, error) {
return mockstomp, nil
}
g.BeforeEach(func() {
server = bogus.New()
server.Start()
})
g.AfterEach(func() {
server.Close()
})
g.It("should send a message", func() {
h, p := server.HostPort()
msg := "the doctor!"
m, err := New(h, p, "user", "pass", DefaultConnectionHeaders)
Expect(err).NotTo(HaveOccurred())
headers := stompngo.Headers{"destination", "queue/badwolf"}
err = m.Send(headers, []byte(msg))
Expect(err).NotTo(HaveOccurred())
Expect(mockstomp.NumMessages).To(Equal(1))
out := <-mockstomp.Messages
Expect(len(out.Headers)).To(Equal(2))
Expect(out.Message).To(Equal(msg))
Expect(out.Order).To(Equal(0))
m.Disconnect()
})
g.It("should apped send headers if set", func() {
h, p := server.HostPort()
msg := "wibbly-wobly"
m, err := New(h, p, "user", "pass", DefaultConnectionHeaders)
Expect(err).NotTo(HaveOccurred())
m.SetSendHeaders(DefaultSendHeaders)
headers := stompngo.Headers{"destination", "queue/doctordonna"}
err = m.Send(headers, []byte(msg))
Expect(err).NotTo(HaveOccurred())
Expect(mockstomp.NumMessages).To(Equal(2))
out := <-mockstomp.Messages
Expect(len(out.Headers)).To(Equal(6))
Expect(out.Message).To(Equal(msg))
Expect(out.Order).To(Equal(0))
m.Disconnect()
})
})
g.Describe("Reading", func() {
var server *bogus.Bogus
mockstomp := mockstompngo.New()
getStompConn = func(n net.Conn, h stompngo.Headers) (connectioner, error) {
return mockstomp, nil
}
g.BeforeEach(func() {
server = bogus.New()
server.Start()
})
g.AfterEach(func() {
server.Close()
})
g.It("should read a message from a broker", func() {
h, p := server.HostPort()
msg := "exterminate! exterminate!"
smsg := stompngo.MessageData{
Message: stompngo.Message{
Body: []uint8(msg),
},
}
mockstomp.PutToSubscribe(smsg)
m, err := New(h, p, "user", "pass", DefaultConnectionHeaders)
Expect(err).NotTo(HaveOccurred())
err = m.Subscribe(DefaultSubscriptionHeaders)
Expect(err).NotTo(HaveOccurred())
n, err := m.Read()
Expect(err).NotTo(HaveOccurred())
Expect(n.Message.BodyString()).To(Equal(msg))
})
})
}
func TestShopifyFullfillments(t *testing.T) {
g := Goblin(t)
RegisterFailHandler(func(m string, _ ...int) { g.Fail(m) })
g.Describe("Fullfillments", func() {
var mockShopify *bogus.Bogus
g.BeforeEach(func() {
mockShopify = bogus.New()
mockShopify.Start()
})
g.AfterEach(func() {
mockShopify.Close()
})
g.Describe("serialization", func() {
g.It("should unmarshal a single fulfillment response without error", func() {
var fulfillmentResponse SingleFulfillmentResponse
err := json.Unmarshal([]byte(SingleFulfillmentsJson), &fulfillmentResponse)
Expect(err).NotTo(HaveOccurred())
Expect(fulfillmentResponse.Fulfillment.Id).To(Equal(int64(1533523203)))
Expect(fulfillmentResponse.Fulfillment.LineItems).To(HaveLen(4))
})
})
g.Describe("CreateFulfillment", func() {
g.It("should send back a single fulfillment after creating a fulfillment", func() {
mock := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Write([]byte(SingleFulfillmentsJson))
}))
s := &Shopify{mock.URL}
c := &Credentials{"some-cart-id", "oauthom"}
fulfillmentJson := `{"fulfillment": {"tracking_number": "9405510200882805665013" }}`
orderId := `2017986627`
fulfillment, err := s.CreateFulfillment(fulfillmentJson, orderId, c, nil)
Expect(err).NotTo(HaveOccurred())
Expect(fulfillment.Id).To(Equal(int64(1533523203)))
Expect(fulfillment.LineItems).To(HaveLen(4))
})
})
g.Describe("Get All", func() {
g.It("should get a single variant by id", func() {
mockShopify.SetPayload([]byte(SampleFullfillmentsJson))
mockShopify.SetStatus(http.StatusOK)
host, port := mockShopify.HostPort()
s := &Shopify{fmt.Sprintf("http://%s:%s", host, port)}
c := &Credentials{"some-cart-id", "oauthom"}
fulfillments, err := s.GetFulfillments("808950810", c, nil)
Expect(err).NotTo(HaveOccurred())
Expect(fulfillments).NotTo(BeNil())
Expect(len(fulfillments)).To(Equal(1))
f := fulfillments[0]
Expect(f).NotTo(BeNil())
Expect(f.Id).To(Equal(int64(255858046)))
Expect(f.OrderId).To(Equal(int64(450789469)))
Expect(f.Status).To(Equal("failure"))
Expect(f.CreatedAt).To(Equal("2015-09-02T14:48:56-04:00"))
Expect(f.Service).To(Equal("manual"))
Expect(f.UpdatedAt).To(Equal("2015-09-02T14:48:56-04:00"))
Expect(f.TrackingCompany).To(Equal(""))
Expect(f.TrackingNumber).To(Equal("1Z2345"))
Expect(len(f.TrackingNumbers)).To(Equal(1))
Expect(f.TrackingNumbers[0]).To(Equal("1Z2345"))
Expect(f.TrackingUrl).To(Equal("http://wwwapps.ups.com/etracking/tracking.cgi?InquiryNumber1=1Z2345&TypeOfInquiryNumber=T&AcceptUPSLicenseAgreement=yes&submit=Track"))
Expect(len(f.TrackingUrls)).To(Equal(1))
Expect(f.TrackingUrls[0]).To(Equal("http://wwwapps.ups.com/etracking/tracking.cgi?InquiryNumber1=1Z2345&TypeOfInquiryNumber=T&AcceptUPSLicenseAgreement=yes&submit=Track"))
Expect(f.Receipt).NotTo(BeNil())
Expect(f.Receipt.TestCase).To(Equal(true))
Expect(f.Receipt.Authorization).To(Equal("123456"))
Expect(len(f.LineItems)).To(Equal(1))
})
})
})
}
func TestSubscription(t *testing.T) {
g := Goblin(t)
RegisterFailHandler(func(m string, _ ...int) { g.Fail(m) })
g.Describe("Subscription Status", func() {
var server *bogus.Bogus
var id, authToken string
g.BeforeEach(func() {
id = "AXXXXXXXX"
authToken = "superhash"
server = bogus.New()
server.SetStatus(200)
server.Start()
})
g.It("should get a subscriptions status", func() {
server.SetPayload(greenStatusXML)
s := &seller.Seller{
id,
authToken,
marketplace.Marketplace{
"NA",
"US",
fmt.Sprintf("http://%v", net.JoinHostPort(server.HostPort())),
"ABCDEFG",
},
auth.Auth{},
}
stat, err := Status(s)
Expect(err).NotTo(HaveOccurred())
Expect(stat).To(Equal("GREEN"))
Expect(server.Hits()).To(Equal(1))
})
g.It("should return an error when it receives an error from MWS", func() {
server.SetPayload(errorXML)
s := &seller.Seller{
id,
authToken,
marketplace.Marketplace{
"NA",
"US",
fmt.Sprintf("http://%v", net.JoinHostPort(server.HostPort())),
"ABCDEFG",
},
auth.Auth{},
}
stat, err := Status(s)
Expect(err).To(HaveOccurred())
Expect(stat).To(Equal(""))
Expect(server.Hits()).To(Equal(1))
})
})
g.Describe("Test Notification", func() {
var server *bogus.Bogus
var id, authToken string
g.BeforeEach(func() {
id = "AXXXXXXXX"
authToken = "superhash"
server = bogus.New()
server.SetStatus(200)
server.Start()
})
g.It("should send a request for a test message on a given queue", func() {
server.SetPayload(testMessageXML)
s := &seller.Seller{
id,
authToken,
marketplace.Marketplace{
"NA",
"US",
fmt.Sprintf("http://%v", net.JoinHostPort(server.HostPort())),
"ABCDEFG",
},
auth.Auth{},
}
err := Test(s, []string{"queue"})
Expect(err).NotTo(HaveOccurred())
Expect(server.Hits()).To(Equal(1))
})
g.It("should return an error when it receives an error from MWS", func() {
server.SetPayload(errorXML)
s := &seller.Seller{
id,
authToken,
marketplace.Marketplace{
"NA",
"US",
fmt.Sprintf("http://%v", net.JoinHostPort(server.HostPort())),
"ABCDEFG",
},
auth.Auth{},
}
err := Test(s, []string{"queue"})
Expect(err).To(HaveOccurred())
Expect(server.Hits()).To(Equal(1))
})
})
}
func TestShopify(t *testing.T) {
g := Goblin(t)
RegisterFailHandler(func(m string, _ ...int) { g.Fail(m) })
g.Describe("Signing", func() {
g.It("should sign a request with an access token", func() {
token := "some-access-token"
req, err := http.NewRequest("GET", "localhost", nil)
Expect(err).NotTo(HaveOccurred())
c := &Credentials{"some-id", token}
c.SignRequest(req)
h := req.Header.Get(AccessHeader)
Expect(h).To(ContainSubstring(token))
})
})
g.Describe("Generic Calls", func() {
var mockShopify *bogus.Bogus
g.BeforeEach(func() {
mockShopify = bogus.New()
mockShopify.Start()
})
g.AfterEach(func() {
mockShopify.Close()
})
g.It("should return a valid cart uri", func() {
cartId := "wakky-wavey-inflatable-waving-arm-guys"
baseUri := "https://%s.myshopify.com"
u, _ := url.Parse(fmt.Sprintf(baseUri, cartId))
s := &Shopify{u.String()}
c := &Credentials{cartId, "some-token"}
uri, err := s.getUri(ProductsEndpoint, c, nil)
Expect(err).NotTo(HaveOccurred())
Expect(uri.Host).To(Equal(fmt.Sprintf("%s.myshopify.com", cartId)))
Expect(uri.Path).To(Equal(ProductsEndpoint))
})
g.It("should return a valid cart uri with params", func() {
cartId := "wakky-wavey-inflatable-waving-arm-guys"
k := "collection"
v := "5555555"
baseUri := "https://%s.myshopify.com"
u, _ := url.Parse(fmt.Sprintf(baseUri, cartId))
s := &Shopify{u.String()}
c := &Credentials{cartId, "some-token"}
p := url.Values{}
p.Add(k, v)
uri, err := s.getUri(ProductsEndpoint, c, p)
Expect(err).NotTo(HaveOccurred())
Expect(uri.Host).To(Equal(fmt.Sprintf("%s.myshopify.com", cartId)))
Expect(uri.Path).To(Equal(ProductsEndpoint))
Expect(uri.Query().Get(k)).To(Equal(v))
})
g.It("should return a valid cart uri with a custom endpoint", func() {
cartId := "wakky-wavey-inflatable-waving-arm-guys"
baseUri := "https://%s.myshopify.com"
productId := "654321"
u, _ := url.Parse(fmt.Sprintf(baseUri, cartId))
s := &Shopify{u.String()}
c := &Credentials{cartId, "some-token"}
uri, err := s.getUri(fmt.Sprintf(ProductEndpoint, productId), c, nil)
Expect(err).NotTo(HaveOccurred())
Expect(uri.Host).To(Equal(fmt.Sprintf("%s.myshopify.com", cartId)))
Expect(uri.Path).To(Equal(fmt.Sprintf(ProductEndpoint, productId)))
})
g.It("should return an error with an invalid cart id", func() {
mockShopify.SetStatus(http.StatusBadRequest)
host, port := mockShopify.HostPort()
u, _ := url.Parse(fmt.Sprintf("http://%s:%s", host, port))
s := &Shopify{u.String()}
c := &Credentials{"some-cart-id", "some-token"}
type TestJson struct {
}
var r TestJson
err := s.DoRequest("GET", u, c, nil, &r)
Expect(err).To(HaveOccurred())
})
g.It("should return an error if bodybytes is 0 length", func() {
mockShopify.SetPayload([]byte(""))
mockShopify.SetStatus(http.StatusBadRequest)
host, port := mockShopify.HostPort()
u, _ := url.Parse(fmt.Sprintf("http://%s:%s", host, port))
s := &Shopify{u.String()}
c := &Credentials{"some-cart-id", "some-token"}
type TestJson struct {
}
var r TestJson
err := s.DoRequest("GET", u, c, nil, &r)
Expect(err).To(HaveOccurred())
})
})
}
func TestShopifyVariants(t *testing.T) {
g := Goblin(t)
RegisterFailHandler(func(m string, _ ...int) { g.Fail(m) })
g.Describe("Variants", func() {
var mockShopify *bogus.Bogus
g.BeforeEach(func() {
mockShopify = bogus.New()
mockShopify.Start()
})
g.AfterEach(func() {
mockShopify.Close()
})
g.Describe("Get One", func() {
g.It("should get a single variant by id", func() {
mockShopify.SetPayload([]byte(SampleVariantJson))
mockShopify.SetStatus(http.StatusOK)
host, port := mockShopify.HostPort()
s := &Shopify{fmt.Sprintf("http://%s:%s", host, port)}
c := &Credentials{"some-cart-hash", "oauthom"}
v, err := s.GetVariant("808950810", c, nil)
Expect(err).NotTo(HaveOccurred())
Expect(v).NotTo(BeNil())
Expect(v.Barcode).To(Equal("1234_pink"))
Expect(v.CompareAtPrice).To(Equal(""))
Expect(v.CreatedAt).To(Equal("2015-03-28T13:31:19-04:03"))
Expect(v.FulfillmentService).To(Equal("manual"))
Expect(v.Grams).To(Equal(float64(200)))
Expect(v.Id).To(Equal(int64(808950810)))
Expect(v.InventoryManagement).To(Equal("shopify"))
Expect(v.InventoryPolicy).To(Equal("continue"))
Expect(v.Option1).To(Equal("Pink"))
Expect(v.Option2).To(Equal(""))
Expect(v.Option3).To(Equal(""))
Expect(v.Position).To(Equal(1))
Expect(v.Price).To(Equal("199.00"))
Expect(v.ProductId).To(Equal(int64(632910392)))
Expect(v.RequiresShipping).To(BeTrue())
Expect(v.Sku).To(Equal("IPOD2008PINK"))
Expect(v.Taxable).To(BeTrue())
Expect(v.Title).To(Equal("Pink"))
Expect(v.UpdatedAt).To(Equal("2015-03-28T13:31:19-04:04"))
Expect(v.InventoryQuantity).To(Equal(int64(10)))
Expect(v.OldInventoryQuantity).To(Equal(int64(10)))
Expect(v.ImageId).To(Equal(int64(562641783)))
Expect(v.Weight).To(Equal(0.2))
Expect(v.WeightUnit).To(Equal("kg"))
})
})
g.Describe("Updating", func() {
g.It("should set variant quantity", func() {
mockShopify.AddPath("/").
SetPayload([]byte(SampleVariantJsonQuantity(5))).
SetStatus(http.StatusOK).
SetMethods("PUT")
host, port := mockShopify.HostPort()
id := int64(1)
oldAmount := int64(1)
newAmount := int64(5)
storeIdentifier := "some-cart-hash"
oauthToken := "oauthom"
update := NewVariantUpdate(id, oldAmount, newAmount, 0)
s := &Shopify{fmt.Sprintf("http://%s:%s", host, port)}
c := &Credentials{storeIdentifier, oauthToken}
v, err := s.PutVariant(strconv.Itoa(int(id)), update, c)
Expect(err).NotTo(HaveOccurred())
Expect(v).NotTo(BeNil())
Expect(v.Id).To(Equal(int64(1)))
Expect(v.InventoryQuantity).To(Equal(int64(5)))
})
g.It("should decrement variant quantity", func() {
mock := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Write([]byte(SampleVariantJsonQuantity(5)))
}))
s := &Shopify{mock.URL}
c := &Credentials{"some-cart-id", "oauthom"}
id := int64(1)
adjustAmount := int64(-5)
update := NewVariantUpdate(id, 0, 0, adjustAmount)
v, err := s.PutVariant(strconv.Itoa(int(id)), update, c)
Expect(err).NotTo(HaveOccurred())
Expect(v).NotTo(BeNil())
Expect(v.Id).To(Equal(int64(1)))
Expect(v.Sku).To(Equal("Sku1"))
Expect(v.InventoryQuantity).To(Equal(int64(5)))
})
g.It("should increment variant quantity", func() {
mock := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Write([]byte(SampleVariantJsonQuantity(15)))
}))
s := &Shopify{mock.URL}
c := &Credentials{"some-cart-id", "oauthom"}
id := int64(1)
adjustAmount := int64(5)
update := NewVariantUpdate(id, 0, 0, adjustAmount)
v, err := s.PutVariant(strconv.Itoa(int(id)), update, c)
Expect(err).NotTo(HaveOccurred())
Expect(v).NotTo(BeNil())
Expect(v.Id).To(Equal(int64(1)))
Expect(v.Sku).To(Equal("Sku1"))
Expect(v.InventoryQuantity).To(Equal(int64(15)))
})
g.It("should not change variant quantity", func() {
mock := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Write([]byte(SampleVariantJsonQuantity(10)))
}))
s := &Shopify{mock.URL}
c := &Credentials{"some-cart-id", "oauthom"}
id := int64(1)
adjustAmount := int64(0)
update := NewVariantUpdate(id, 0, 0, adjustAmount)
v, err := s.PutVariant(strconv.Itoa(int(id)), update, c)
Expect(err).NotTo(HaveOccurred())
Expect(v).NotTo(BeNil())
Expect(v.Id).To(Equal(int64(1)))
Expect(v.Sku).To(Equal("Sku1"))
Expect(v.InventoryQuantity).To(Equal(int64(10)))
})
})
})
}
func TestShopifyProducts(t *testing.T) {
g := Goblin(t)
RegisterFailHandler(func(m string, _ ...int) { g.Fail(m) })
g.Describe("Products", func() {
var mockShopify *bogus.Bogus
g.BeforeEach(func() {
mockShopify = bogus.New()
mockShopify.Start()
})
g.AfterEach(func() {
mockShopify.Close()
})
g.Describe("Get All", func() {
g.It("should get a list of products from shopify", func() {
mockShopify.SetPayload([]byte(SampleProductsJson))
mockShopify.SetStatus(http.StatusOK)
host, port := mockShopify.HostPort()
s := &Shopify{fmt.Sprintf("http://%s:%s", host, port)}
c := &Credentials{"some-cart-hash", "oauthom"}
p, err := s.GetProducts(c, nil)
Expect(err).NotTo(HaveOccurred())
Expect(p).NotTo(BeNil())
Expect(len(p)).To(Equal(2))
Expect(p[0].BodyHtml).To(ContainSubstring("It's the small iPod with one very big idea"))
Expect(p[0].CreatedAt).To(Equal("2015-03-28T13:31:19-04:01"))
Expect(p[0].Handle).To(Equal("ipod-nano"))
Expect(p[0].Id).To(Equal(int64(632910392)))
Expect(p[0].ProductType).To(Equal("Cult Products"))
Expect(p[0].PublishedAt).To(Equal("2007-12-31T19:00:00-05:00"))
Expect(p[0].PublishedScope).To(Equal("web"))
Expect(p[0].TemplateSuffix).To(Equal(""))
Expect(p[0].Title).To(Equal("IPod Nano - 8GB"))
Expect(p[0].UpdatedAt).To(Equal("2015-03-28T13:31:19-04:02"))
Expect(p[0].Vendor).To(Equal("Apple"))
Expect(p[0].Tags).To(Equal("Emotive, Flash Memory, MP3, Music"))
Expect(len(p[0].Variants)).To(Equal(4))
Expect(p[0].Variants[0].Barcode).To(Equal("1234_pink"))
Expect(p[0].Variants[0].CompareAtPrice).To(Equal(""))
Expect(p[0].Variants[0].CreatedAt).To(Equal("2015-03-28T13:31:19-04:03"))
Expect(p[0].Variants[0].FulfillmentService).To(Equal("manual"))
Expect(p[0].Variants[0].Grams).To(Equal(float64(200)))
Expect(p[0].Variants[0].Id).To(Equal(int64(808950810)))
Expect(p[0].Variants[0].InventoryManagement).To(Equal("shopify"))
Expect(p[0].Variants[0].InventoryPolicy).To(Equal("continue"))
Expect(p[0].Variants[0].Option1).To(Equal("Pink"))
Expect(p[0].Variants[0].Option2).To(Equal(""))
Expect(p[0].Variants[0].Option3).To(Equal(""))
Expect(p[0].Variants[0].Position).To(Equal(1))
Expect(p[0].Variants[0].Price).To(Equal("199.00"))
Expect(p[0].Variants[0].ProductId).To(Equal(int64(632910392)))
Expect(p[0].Variants[0].RequiresShipping).To(BeTrue())
Expect(p[0].Variants[0].Sku).To(Equal("IPOD2008PINK"))
Expect(p[0].Variants[0].Taxable).To(BeTrue())
Expect(p[0].Variants[0].Title).To(Equal("Pink"))
Expect(p[0].Variants[0].UpdatedAt).To(Equal("2015-03-28T13:31:19-04:04"))
Expect(p[0].Variants[0].InventoryQuantity).To(Equal(int64(10)))
Expect(p[0].Variants[0].OldInventoryQuantity).To(Equal(int64(10)))
Expect(p[0].Variants[0].ImageId).To(Equal(int64(562641783)))
Expect(p[0].Variants[0].Weight).To(Equal(0.2))
Expect(p[0].Variants[0].WeightUnit).To(Equal("kg"))
Expect(p[0].Variants[1].Barcode).To(Equal("1234_red"))
Expect(p[0].Variants[1].CompareAtPrice).To(Equal(""))
Expect(p[0].Variants[1].CreatedAt).To(Equal("2015-03-28T13:31:19-04:05"))
Expect(p[0].Variants[1].FulfillmentService).To(Equal("manual"))
Expect(p[0].Variants[1].Grams).To(Equal(float64(200)))
Expect(p[0].Variants[1].Id).To(Equal(int64(49148385)))
Expect(p[0].Variants[1].InventoryManagement).To(Equal("shopify"))
Expect(p[0].Variants[1].InventoryPolicy).To(Equal("continue"))
Expect(p[0].Variants[1].Option1).To(Equal("Red"))
Expect(p[0].Variants[1].Option2).To(Equal(""))
Expect(p[0].Variants[1].Option3).To(Equal(""))
Expect(p[0].Variants[1].Position).To(Equal(2))
Expect(p[0].Variants[1].Price).To(Equal("199.00"))
Expect(p[0].Variants[1].ProductId).To(Equal(int64(632910392)))
Expect(p[0].Variants[1].RequiresShipping).To(BeTrue())
Expect(p[0].Variants[1].Sku).To(Equal("IPOD2008RED"))
Expect(p[0].Variants[1].Taxable).To(BeTrue())
Expect(p[0].Variants[1].Title).To(Equal("Red"))
Expect(p[0].Variants[1].UpdatedAt).To(Equal("2015-03-28T13:31:19-04:06"))
Expect(p[0].Variants[1].InventoryQuantity).To(Equal(int64(20)))
Expect(p[0].Variants[1].OldInventoryQuantity).To(Equal(int64(20)))
Expect(p[0].Variants[1].ImageId).To(Equal(int64(0)))
Expect(p[0].Variants[1].Weight).To(Equal(0.2))
Expect(p[0].Variants[1].WeightUnit).To(Equal("kg"))
Expect(len(p[0].Options)).To(Equal(1))
Expect(p[0].Options[0].Id).To(Equal(int64(594680422)))
Expect(p[0].Options[0].Name).To(Equal("Title"))
Expect(p[0].Options[0].Position).To(Equal(1))
Expect(p[0].Options[0].ProductId).To(Equal(int64(632910392)))
Expect(len(p[0].Images)).To(Equal(2))
Expect(p[0].Images[0].CreatedAt).To(Equal("2015-03-28T13:31:19-04:07"))
Expect(p[0].Images[0].Id).To(Equal(int64(850703190)))
Expect(p[0].Images[0].Position).To(Equal(1))
Expect(p[0].Images[0].ProductId).To(Equal(int64(632910392)))
Expect(p[0].Images[0].UpdatedAt).To(Equal("2015-03-28T13:31:19-04:08"))
Expect(p[0].Images[0].Source).To(Equal("https://cdn.shopify.com/s/files/1/0006/9093/3842/products/ipod-nano.png?v=1427563879"))
Expect(len(p[0].Images[0].VariantIds)).To(Equal(0))
Expect(p[0].Images[1].CreatedAt).To(Equal("2015-03-28T13:31:19-04:09"))
Expect(p[0].Images[1].Id).To(Equal(int64(562641783)))
Expect(p[0].Images[1].Position).To(Equal(2))
Expect(p[0].Images[1].ProductId).To(Equal(int64(632910392)))
Expect(p[0].Images[1].UpdatedAt).To(Equal("2015-03-28T13:31:19-04:10"))
Expect(p[0].Images[1].Source).To(Equal("https://cdn.shopify.com/s/files/1/0006/9093/3842/products/ipod-nano-2.png?v=1427563879"))
Expect(p[0].Images[1].VariantIds[0]).To(Equal(int64(808950810)))
Expect(p[0].Image.CreatedAt).To(Equal("2015-03-28T13:31:19-04:11"))
Expect(p[0].Image.Id).To(Equal(int64(850703190)))
Expect(p[0].Image.Position).To(Equal(1))
Expect(p[0].Image.ProductId).To(Equal(int64(632910392)))
Expect(p[0].Image.UpdatedAt).To(Equal("2015-03-28T13:31:19-04:12"))
Expect(p[0].Image.Source).To(Equal("https://cdn.shopify.com/s/files/1/0006/9093/3842/products/ipod-nano.png?v=1427563879"))
Expect(len(p[0].Image.VariantIds)).To(Equal(0))
Expect(len(p[1].Variants)).To(Equal(1))
Expect(len(p[1].Options)).To(Equal(1))
Expect(len(p[1].Images)).To(Equal(0))
Expect(mockShopify.Hits()).To(Equal(1))
})
g.It("should return an offset list of products", func() {
mockShopify.SetPayload([]byte(SampleProductsJson))
mockShopify.SetStatus(http.StatusOK)
host, port := mockShopify.HostPort()
s := &Shopify{fmt.Sprintf("http://%s:%s", host, port)}
c := &Credentials{"some-cart-hash", "oauthom"}
params := url.Values{}
params.Add("page", "2")
p, err := s.GetProducts(c, params)
Expect(err).NotTo(HaveOccurred())
Expect(p).NotTo(BeNil())
Expect(len(p)).To(Equal(2))
Expect(p[0].BodyHtml).To(ContainSubstring("It's the small iPod with one very big idea"))
Expect(p[0].CreatedAt).To(Equal("2015-03-28T13:31:19-04:01"))
Expect(p[0].Handle).To(Equal("ipod-nano"))
Expect(p[0].Id).To(Equal(int64(632910392)))
Expect(p[0].ProductType).To(Equal("Cult Products"))
Expect(p[0].PublishedAt).To(Equal("2007-12-31T19:00:00-05:00"))
Expect(p[0].PublishedScope).To(Equal("web"))
Expect(p[0].TemplateSuffix).To(Equal(""))
Expect(p[0].Title).To(Equal("IPod Nano - 8GB"))
Expect(p[0].UpdatedAt).To(Equal("2015-03-28T13:31:19-04:02"))
Expect(p[0].Vendor).To(Equal("Apple"))
Expect(p[0].Tags).To(Equal("Emotive, Flash Memory, MP3, Music"))
Expect(len(p[0].Variants)).To(Equal(4))
Expect(p[0].Variants[0].Barcode).To(Equal("1234_pink"))
Expect(p[0].Variants[0].CompareAtPrice).To(Equal(""))
Expect(p[0].Variants[0].CreatedAt).To(Equal("2015-03-28T13:31:19-04:03"))
Expect(p[0].Variants[0].FulfillmentService).To(Equal("manual"))
Expect(p[0].Variants[0].Grams).To(Equal(float64(200)))
Expect(p[0].Variants[0].Id).To(Equal(int64(808950810)))
Expect(p[0].Variants[0].InventoryManagement).To(Equal("shopify"))
Expect(p[0].Variants[0].InventoryPolicy).To(Equal("continue"))
Expect(p[0].Variants[0].Option1).To(Equal("Pink"))
Expect(p[0].Variants[0].Option2).To(Equal(""))
Expect(p[0].Variants[0].Option3).To(Equal(""))
Expect(p[0].Variants[0].Position).To(Equal(1))
Expect(p[0].Variants[0].Price).To(Equal("199.00"))
Expect(p[0].Variants[0].ProductId).To(Equal(int64(632910392)))
Expect(p[0].Variants[0].RequiresShipping).To(BeTrue())
Expect(p[0].Variants[0].Sku).To(Equal("IPOD2008PINK"))
Expect(p[0].Variants[0].Taxable).To(BeTrue())
Expect(p[0].Variants[0].Title).To(Equal("Pink"))
Expect(p[0].Variants[0].UpdatedAt).To(Equal("2015-03-28T13:31:19-04:04"))
Expect(p[0].Variants[0].InventoryQuantity).To(Equal(int64(10)))
Expect(p[0].Variants[0].OldInventoryQuantity).To(Equal(int64(10)))
Expect(p[0].Variants[0].ImageId).To(Equal(int64(562641783)))
Expect(p[0].Variants[0].Weight).To(Equal(0.2))
Expect(p[0].Variants[0].WeightUnit).To(Equal("kg"))
Expect(p[0].Variants[1].Barcode).To(Equal("1234_red"))
Expect(p[0].Variants[1].CompareAtPrice).To(Equal(""))
Expect(p[0].Variants[1].CreatedAt).To(Equal("2015-03-28T13:31:19-04:05"))
Expect(p[0].Variants[1].FulfillmentService).To(Equal("manual"))
Expect(p[0].Variants[1].Grams).To(Equal(float64(200)))
Expect(p[0].Variants[1].Id).To(Equal(int64(49148385)))
Expect(p[0].Variants[1].InventoryManagement).To(Equal("shopify"))
Expect(p[0].Variants[1].InventoryPolicy).To(Equal("continue"))
Expect(p[0].Variants[1].Option1).To(Equal("Red"))
Expect(p[0].Variants[1].Option2).To(Equal(""))
Expect(p[0].Variants[1].Option3).To(Equal(""))
Expect(p[0].Variants[1].Position).To(Equal(2))
Expect(p[0].Variants[1].Price).To(Equal("199.00"))
Expect(p[0].Variants[1].ProductId).To(Equal(int64(632910392)))
Expect(p[0].Variants[1].RequiresShipping).To(BeTrue())
Expect(p[0].Variants[1].Sku).To(Equal("IPOD2008RED"))
Expect(p[0].Variants[1].Taxable).To(BeTrue())
Expect(p[0].Variants[1].Title).To(Equal("Red"))
Expect(p[0].Variants[1].UpdatedAt).To(Equal("2015-03-28T13:31:19-04:06"))
Expect(p[0].Variants[1].InventoryQuantity).To(Equal(int64(20)))
Expect(p[0].Variants[1].OldInventoryQuantity).To(Equal(int64(20)))
Expect(p[0].Variants[1].ImageId).To(Equal(int64(0)))
Expect(p[0].Variants[1].Weight).To(Equal(0.2))
Expect(p[0].Variants[1].WeightUnit).To(Equal("kg"))
Expect(len(p[0].Options)).To(Equal(1))
Expect(p[0].Options[0].Id).To(Equal(int64(594680422)))
Expect(p[0].Options[0].Name).To(Equal("Title"))
Expect(p[0].Options[0].Position).To(Equal(1))
Expect(p[0].Options[0].ProductId).To(Equal(int64(632910392)))
Expect(len(p[0].Images)).To(Equal(2))
Expect(p[0].Images[0].CreatedAt).To(Equal("2015-03-28T13:31:19-04:07"))
Expect(p[0].Images[0].Id).To(Equal(int64(850703190)))
Expect(p[0].Images[0].Position).To(Equal(1))
Expect(p[0].Images[0].ProductId).To(Equal(int64(632910392)))
Expect(p[0].Images[0].UpdatedAt).To(Equal("2015-03-28T13:31:19-04:08"))
Expect(p[0].Images[0].Source).To(Equal("https://cdn.shopify.com/s/files/1/0006/9093/3842/products/ipod-nano.png?v=1427563879"))
Expect(len(p[0].Images[0].VariantIds)).To(Equal(0))
Expect(p[0].Images[1].CreatedAt).To(Equal("2015-03-28T13:31:19-04:09"))
Expect(p[0].Images[1].Id).To(Equal(int64(562641783)))
Expect(p[0].Images[1].Position).To(Equal(2))
Expect(p[0].Images[1].ProductId).To(Equal(int64(632910392)))
Expect(p[0].Images[1].UpdatedAt).To(Equal("2015-03-28T13:31:19-04:10"))
Expect(p[0].Images[1].Source).To(Equal("https://cdn.shopify.com/s/files/1/0006/9093/3842/products/ipod-nano-2.png?v=1427563879"))
Expect(p[0].Images[1].VariantIds[0]).To(Equal(int64(808950810)))
Expect(p[0].Image.CreatedAt).To(Equal("2015-03-28T13:31:19-04:11"))
Expect(p[0].Image.Id).To(Equal(int64(850703190)))
Expect(p[0].Image.Position).To(Equal(1))
Expect(p[0].Image.ProductId).To(Equal(int64(632910392)))
Expect(p[0].Image.UpdatedAt).To(Equal("2015-03-28T13:31:19-04:12"))
Expect(p[0].Image.Source).To(Equal("https://cdn.shopify.com/s/files/1/0006/9093/3842/products/ipod-nano.png?v=1427563879"))
Expect(len(p[0].Image.VariantIds)).To(Equal(0))
Expect(len(p[1].Variants)).To(Equal(1))
Expect(len(p[1].Options)).To(Equal(1))
Expect(len(p[1].Images)).To(Equal(0))
Expect(mockShopify.Hits()).To(Equal(1))
})
g.It("should return a limited list of products", func() {
mockShopify.SetPayload([]byte(SampleProductsLimitedJson))
mockShopify.SetStatus(http.StatusOK)
host, port := mockShopify.HostPort()
s := &Shopify{fmt.Sprintf("http://%s:%s", host, port)}
c := &Credentials{"some-cart-hash", "oauthom"}
params := url.Values{}
params.Add("limit", "1")
p, err := s.GetProducts(c, params)
Expect(err).NotTo(HaveOccurred())
Expect(p).NotTo(BeNil())
Expect(len(p)).To(Equal(1))
Expect(p[0].BodyHtml).To(ContainSubstring("The iPod Touch has the iPhone's multi-touch interface"))
Expect(p[0].CreatedAt).To(Equal("2015-03-28T13:31:19-04:20"))
Expect(p[0].Handle).To(Equal("ipod-touch"))
Expect(p[0].Id).To(Equal(int64(921728736)))
Expect(p[0].ProductType).To(Equal("Cult Products"))
Expect(p[0].PublishedAt).To(Equal("2008-09-25T20:00:00-04:00"))
Expect(p[0].PublishedScope).To(Equal("global"))
Expect(p[0].TemplateSuffix).To(Equal(""))
Expect(p[0].Title).To(Equal("IPod Touch 8GB"))
Expect(p[0].UpdatedAt).To(Equal("2015-03-28T13:31:19-04:00"))
Expect(p[0].Vendor).To(Equal("Apple"))
Expect(p[0].Tags).To(Equal(""))
Expect(len(p[0].Variants)).To(Equal(1))
Expect(p[0].Variants[0].Barcode).To(Equal("1234_black"))
Expect(p[0].Variants[0].CompareAtPrice).To(Equal(""))
Expect(p[0].Variants[0].CreatedAt).To(Equal("2015-03-28T13:31:19-04:00"))
Expect(p[0].Variants[0].FulfillmentService).To(Equal("manual"))
Expect(p[0].Variants[0].Grams).To(Equal(float64(200)))
Expect(p[0].Variants[0].Id).To(Equal(int64(447654529)))
Expect(p[0].Variants[0].InventoryManagement).To(Equal("shopify"))
Expect(p[0].Variants[0].InventoryPolicy).To(Equal("continue"))
Expect(p[0].Variants[0].Option1).To(Equal("Black"))
Expect(p[0].Variants[0].Option2).To(Equal(""))
Expect(p[0].Variants[0].Option3).To(Equal(""))
Expect(p[0].Variants[0].Position).To(Equal(1))
Expect(p[0].Variants[0].Price).To(Equal("199.00"))
Expect(p[0].Variants[0].ProductId).To(Equal(int64(921728736)))
Expect(p[0].Variants[0].RequiresShipping).To(BeTrue())
Expect(p[0].Variants[0].Sku).To(Equal("IPOD2009BLACK"))
Expect(p[0].Variants[0].Taxable).To(BeTrue())
Expect(p[0].Variants[0].Title).To(Equal("Black"))
Expect(p[0].Variants[0].UpdatedAt).To(Equal("2015-03-28T13:31:19-04:00"))
Expect(p[0].Variants[0].InventoryQuantity).To(Equal(int64(13)))
Expect(p[0].Variants[0].OldInventoryQuantity).To(Equal(int64(13)))
Expect(p[0].Variants[0].ImageId).To(Equal(int64(0)))
Expect(p[0].Variants[0].Weight).To(Equal(0.2))
Expect(p[0].Variants[0].WeightUnit).To(Equal("kg"))
Expect(len(p[0].Options)).To(Equal(1))
Expect(p[0].Options[0].Id).To(Equal(int64(891236591)))
Expect(p[0].Options[0].Name).To(Equal("Title"))
Expect(p[0].Options[0].Position).To(Equal(1))
Expect(p[0].Options[0].ProductId).To(Equal(int64(921728736)))
Expect(len(p[0].Images)).To(Equal(0))
Expect(mockShopify.Hits()).To(Equal(1))
})
})
g.Describe("Get One", func() {
g.It("should get a single product", func() {
mockShopify.SetPayload([]byte(SampleProductJson))
mockShopify.SetStatus(http.StatusOK)
host, port := mockShopify.HostPort()
s := &Shopify{fmt.Sprintf("http://%s:%s", host, port)}
c := &Credentials{"some-cart-hash", "oauthom"}
p, err := s.GetProduct("632910392", c, nil)
Expect(err).NotTo(HaveOccurred())
Expect(p).NotTo(BeNil())
Expect(p.BodyHtml).To(ContainSubstring("It's the small iPod with one very big idea"))
Expect(p.CreatedAt).To(Equal("2015-03-28T13:31:19-04:01"))
Expect(p.Handle).To(Equal("ipod-nano"))
Expect(p.Id).To(Equal(int64(632910392)))
Expect(p.ProductType).To(Equal("Cult Products"))
Expect(p.PublishedAt).To(Equal("2007-12-31T19:00:00-05:00"))
Expect(p.PublishedScope).To(Equal("web"))
Expect(p.TemplateSuffix).To(Equal(""))
Expect(p.Title).To(Equal("IPod Nano - 8GB"))
Expect(p.UpdatedAt).To(Equal("2015-03-28T13:31:19-04:02"))
Expect(p.Vendor).To(Equal("Apple"))
Expect(p.Tags).To(Equal("Emotive, Flash Memory, MP3, Music"))
Expect(len(p.Variants)).To(Equal(4))
Expect(p.Variants[0].Barcode).To(Equal("1234_pink"))
Expect(p.Variants[0].CompareAtPrice).To(Equal(""))
Expect(p.Variants[0].CreatedAt).To(Equal("2015-03-28T13:31:19-04:03"))
Expect(p.Variants[0].FulfillmentService).To(Equal("manual"))
Expect(p.Variants[0].Grams).To(Equal(float64(200)))
Expect(p.Variants[0].Id).To(Equal(int64(808950810)))
Expect(p.Variants[0].InventoryManagement).To(Equal("shopify"))
Expect(p.Variants[0].InventoryPolicy).To(Equal("continue"))
Expect(p.Variants[0].Option1).To(Equal("Pink"))
Expect(p.Variants[0].Option2).To(Equal(""))
Expect(p.Variants[0].Option3).To(Equal(""))
Expect(p.Variants[0].Position).To(Equal(1))
Expect(p.Variants[0].Price).To(Equal("199.00"))
Expect(p.Variants[0].ProductId).To(Equal(int64(632910392)))
Expect(p.Variants[0].RequiresShipping).To(BeTrue())
Expect(p.Variants[0].Sku).To(Equal("IPOD2008PINK"))
Expect(p.Variants[0].Taxable).To(BeTrue())
Expect(p.Variants[0].Title).To(Equal("Pink"))
Expect(p.Variants[0].UpdatedAt).To(Equal("2015-03-28T13:31:19-04:04"))
Expect(p.Variants[0].InventoryQuantity).To(Equal(int64(10)))
Expect(p.Variants[0].OldInventoryQuantity).To(Equal(int64(10)))
Expect(p.Variants[0].ImageId).To(Equal(int64(562641783)))
Expect(p.Variants[0].Weight).To(Equal(0.2))
Expect(p.Variants[0].WeightUnit).To(Equal("kg"))
Expect(p.Variants[1].Barcode).To(Equal("1234_red"))
Expect(p.Variants[1].CompareAtPrice).To(Equal(""))
Expect(p.Variants[1].CreatedAt).To(Equal("2015-03-28T13:31:19-04:05"))
Expect(p.Variants[1].FulfillmentService).To(Equal("manual"))
Expect(p.Variants[1].Grams).To(Equal(float64(200)))
Expect(p.Variants[1].Id).To(Equal(int64(49148385)))
Expect(p.Variants[1].InventoryManagement).To(Equal("shopify"))
Expect(p.Variants[1].InventoryPolicy).To(Equal("continue"))
Expect(p.Variants[1].Option1).To(Equal("Red"))
Expect(p.Variants[1].Option2).To(Equal(""))
Expect(p.Variants[1].Option3).To(Equal(""))
Expect(p.Variants[1].Position).To(Equal(2))
Expect(p.Variants[1].Price).To(Equal("199.00"))
Expect(p.Variants[1].ProductId).To(Equal(int64(632910392)))
Expect(p.Variants[1].RequiresShipping).To(BeTrue())
Expect(p.Variants[1].Sku).To(Equal("IPOD2008RED"))
Expect(p.Variants[1].Taxable).To(BeTrue())
Expect(p.Variants[1].Title).To(Equal("Red"))
Expect(p.Variants[1].UpdatedAt).To(Equal("2015-03-28T13:31:19-04:06"))
Expect(p.Variants[1].InventoryQuantity).To(Equal(int64(20)))
Expect(p.Variants[1].OldInventoryQuantity).To(Equal(int64(20)))
Expect(p.Variants[1].ImageId).To(Equal(int64(0)))
Expect(p.Variants[1].Weight).To(Equal(0.2))
Expect(p.Variants[1].WeightUnit).To(Equal("kg"))
Expect(len(p.Options)).To(Equal(1))
Expect(p.Options[0].Id).To(Equal(int64(594680422)))
Expect(p.Options[0].Name).To(Equal("Title"))
Expect(p.Options[0].Position).To(Equal(1))
Expect(p.Options[0].ProductId).To(Equal(int64(632910392)))
Expect(len(p.Images)).To(Equal(2))
Expect(p.Images[0].CreatedAt).To(Equal("2015-03-28T13:31:19-04:07"))
Expect(p.Images[0].Id).To(Equal(int64(850703190)))
Expect(p.Images[0].Position).To(Equal(1))
Expect(p.Images[0].ProductId).To(Equal(int64(632910392)))
Expect(p.Images[0].UpdatedAt).To(Equal("2015-03-28T13:31:19-04:08"))
Expect(p.Images[0].Source).To(Equal("https://cdn.shopify.com/s/files/1/0006/9093/3842/products/ipod-nano.png?v=1427563879"))
Expect(len(p.Images[0].VariantIds)).To(Equal(0))
Expect(p.Images[1].CreatedAt).To(Equal("2015-03-28T13:31:19-04:09"))
Expect(p.Images[1].Id).To(Equal(int64(562641783)))
Expect(p.Images[1].Position).To(Equal(2))
Expect(p.Images[1].ProductId).To(Equal(int64(632910392)))
Expect(p.Images[1].UpdatedAt).To(Equal("2015-03-28T13:31:19-04:10"))
Expect(p.Images[1].Source).To(Equal("https://cdn.shopify.com/s/files/1/0006/9093/3842/products/ipod-nano-2.png?v=1427563879"))
Expect(p.Images[1].VariantIds[0]).To(Equal(int64(808950810)))
Expect(p.Image.CreatedAt).To(Equal("2015-03-28T13:31:19-04:11"))
Expect(p.Image.Id).To(Equal(int64(850703190)))
Expect(p.Image.Position).To(Equal(1))
Expect(p.Image.ProductId).To(Equal(int64(632910392)))
Expect(p.Image.UpdatedAt).To(Equal("2015-03-28T13:31:19-04:12"))
Expect(p.Image.Source).To(Equal("https://cdn.shopify.com/s/files/1/0006/9093/3842/products/ipod-nano.png?v=1427563879"))
Expect(len(p.Image.VariantIds)).To(Equal(0))
})
})
g.Describe("Count", func() {
g.It("should get a products count", func() {
mockShopify.SetPayload([]byte(SampleProductsCountJson))
mockShopify.SetStatus(http.StatusOK)
host, port := mockShopify.HostPort()
s := &Shopify{fmt.Sprintf("http://%s:%s", host, port)}
c := &Credentials{"some-cart-hash", "oauthom"}
count, err := s.GetProductsCount(c, nil)
Expect(err).NotTo(HaveOccurred())
Expect(count.Count).To(Equal(int64(20)))
})
g.It("should get a products count that belong to a certain collection", func() {
mockShopify.SetPayload([]byte(SampleProductsCountCollectionJson))
mockShopify.SetStatus(http.StatusOK)
host, port := mockShopify.HostPort()
s := &Shopify{fmt.Sprintf("http://%s:%s", host, port)}
c := &Credentials{"some-cart-hash", "oauthom"}
params := url.Values{}
params.Add("collection_id", "841564295")
count, err := s.GetProductsCount(c, params)
Expect(err).NotTo(HaveOccurred())
Expect(count.Count).To(Equal(int64(1)))
})
})
})
}