crystal_api 0.0.1

data/spec/crystal_api/store_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe CrystalApi::Store do
+  describe "#from_json" do
+    let(:json_hash) {{
+      "store" => {
+        "name"          => "Arux Gaming Store",
+        "database_name" => "arux"
+      }
+    }}
+
+    subject { CrystalApi::Store.from_json(json_hash) }
+
+    its(:name)           { should == "Arux Gaming Store" }
+    its(:database_name) { should == "arux" }
+  end
+end

data/spec/crystal_api/variant_descriptor_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe CrystalApi::VariantDescriptor do
+  describe ".from_json" do
+    let(:json_hash) {{
+      'variant_descriptor' => {
+        'name' => 'Condition',
+        'value' => 'Near Mint'
+      }
+    }}
+
+    subject { CrystalApi::VariantDescriptor.from_json(json_hash) }
+    its(:name) { should == 'Condition' }
+    its(:value) { should == 'Near Mint' }
+  end
+end

data/spec/crystal_api/variant_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+
+describe CrystalApi::Variant do
+  describe "#id" do
+    let(:attribute) { :id }
+    it_should_behave_like "integer attribute"
+  end
+
+  describe "#product_id" do
+    let(:attribute) { :product_id }
+    it_should_behave_like "integer attribute"
+  end
+
+  describe "#qty" do
+    let(:attribute) { :qty }
+    it_should_behave_like "integer attribute"
+  end
+
+  describe "#wtb_qty" do
+    let(:attribute) { :wtb_qty }
+    it_should_behave_like "integer attribute"
+  end
+
+  describe "#catalog_id" do
+    let(:attribute) { :catalog_id }
+    it_should_behave_like "string attribute"
+  end
+
+  describe "#is_default" do
+    let(:attribute) { :is_default }
+    it_should_behave_like "boolean attribute"
+
+    it "defines the default? method" do
+      CrystalApi::Variant.new(is_default: true).default?.should == true
+    end
+  end
+
+  describe "#is_infinite_qty" do
+    let(:attribute) { :is_infinite_qty }
+    it_should_behave_like "boolean attribute"
+
+    it "defines the infinite_qty? method" do
+      CrystalApi::Variant.new(is_infinite_qty: true).infinite_qty?.should == true
+    end
+  end
+
+  describe ".from_json" do
+    let(:json_hash) {{
+      'variant' => {
+        'id'                     => 123,
+        'is_default'             => false,
+        'is_infinite_qty'        => false,
+        'product_id'             => 12,
+        'qty'                    => 2,
+        'wtb_qty'                => 8,
+        'sell_price'             => {'money' => {'cents' => 500, 'currency' => 'USD'}},
+        'buy_price'              => {'money' => {'cents' => 100, 'currency' => 'USD'}},
+        'store_credit_buy_price' => {'money' => {'cents' => 130, 'currency' => 'USD'}},
+        'catalog_id'             => 'skusku',
+        'product_catalog_id'     => 55,
+        'product_name'           => "Lotus Cobra",
+        'category_name'          => "Zendikar",
+        'descriptors' => [
+          {
+            'variant_descriptor' => {
+              'name' => 'Condition',
+              'value' => 'Near Mint',
+            }
+          }
+        ]
+      }}}
+    subject { CrystalApi::Variant.from_json(json_hash) }
+    its(:id) { should == 123 }
+    its(:product_id) { should == 12 }
+    its(:descriptors) { should == [
+      CrystalApi::VariantDescriptor.new(name: 'Condition', value: 'Near Mint')
+    ] }
+    its(:sell_price) { should == Money.new(500) }
+    its(:buy_price) { should == Money.new(100) }
+    its(:store_credit_buy_price) { should == Money.new(130) }
+    its(:product_catalog_id) { should == 55 }
+    its(:product_name) { should == "Lotus Cobra" }
+    its(:category_name) { should == "Zendikar" }
+  end
+end

data/spec/crystal_api/webhook_envelope_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe CrystalApi::WebhookEnvelope do
+
+  subject { CrystalApi::WebhookEnvelope.new }
+
+  describe "#from_json" do
+    let(:json_hash) {{
+      "webhook_envelope" => {
+        "topic"       => "product/update",
+        "store_name"  => "examplestore",
+        "resource_id" => 385,
+        "payload"     => {'variant' => {'id' => 1}}}
+    }}
+
+    subject { CrystalApi::WebhookEnvelope.from_json(json_hash) }
+
+    its(:topic)       { should == "product/update" }
+    its(:store_name)  { should == "examplestore"}
+    its(:resource_id) { should == 385 }
+    its(:payload)     { should be_a(CrystalApi::Variant) }
+
+    context "multiple items in the payload" do
+      let(:json_hash) {{
+        "webhook_envelope" => {
+          "topic"       => "product/update",
+          "store_name"  => "examplestore",
+          "resource_id" => 385,
+          "payload"     => [
+            {'variant' => {'id' => 1}},
+            {'variant' => {'id' => 2}}
+          ]}
+      }}
+
+      subject { CrystalApi::WebhookEnvelope.from_json(json_hash) }
+
+      it "has both variants in the payload" do
+        subject.payload.should == [
+          CrystalApi::Variant.new(id: 1),
+          CrystalApi::Variant.new(id: 2)
+        ]
+      end
+    end
+  end
+end

data/spec/crystal_api/webhook_registration_spec.rb

@@ -0,0 +1,129 @@
+require 'spec_helper'
+
+describe CrystalApi::WebhookRegistration do
+  let(:store_endpoint) { mock("Store Endpoint") }
+
+  subject { CrystalApi::WebhookRegistration.new(store_endpoint) }
+
+  describe "#register" do
+    let(:parsed_response) { mock("Parsed Response") }
+    let(:webhook) { mock("Webhook", :to_json => "{}") }
+
+    before(:each) do
+      store_endpoint.stub(:post).and_return(parsed_response)
+    end
+
+    it "configures the json to exclude the id in the body" do
+      webhook.should_receive(:to_json).with(except: [:id])
+      subject.register(webhook)
+    end
+
+    it "posts the webhook json to the store endpoint" do
+      store_endpoint.should_receive(:post).with('/webhooks', "{}")
+      subject.register(webhook)
+    end
+
+    it "returns the parsed response" do
+      subject.register(webhook).should == parsed_response
+    end
+  end
+
+  describe "#registered?" do
+    let(:parsed_response) { mock("Parsed Response", :parsed => existing_webhooks) }
+    let(:existing_webhooks) { [] }
+    let(:existing_webhook) { mock("Webhook", address: 'url',
+                                             topic: 'pages/update',
+                                             resource_id: nil,
+                                             id: 11) }
+    let(:webhook) { mock("Webhook", address: 'url',
+                                    topic: 'pages/update',
+                                    resource_id: nil) }
+
+    before(:each) do
+      store_endpoint.stub(:get).and_return(parsed_response)
+    end
+
+    it "gets all the existing webhooks" do
+      store_endpoint.should_receive(:get).with('/webhooks')
+      subject.registered?(webhook)
+    end
+
+    context "one of the returned webhooks the webhook we already have" do
+      let(:existing_webhooks) { [existing_webhook] }
+
+      it "returns true" do
+        subject.registered?(webhook).should be_true
+      end
+    end
+
+    context "the webhook we want is not registered" do
+      it "returns false" do
+        subject.registered?(webhook).should be_false
+      end
+    end
+  end
+
+  describe "#deregister" do
+    it "makes a delete request to the endpoint" do
+      store_endpoint.should_receive(:delete).with("/webhooks/11")
+      subject.deregister(11)
+    end
+  end
+
+  describe "registered_webhooks" do
+    let(:parsed_response) { mock("Parsed Response", :parsed => existing_webhooks) }
+    let(:existing_webhooks) { [existing_webhook] }
+    let(:existing_webhook) { mock("Webhook", address: 'url',
+                                             topic: 'pages/update',
+                                             resource_id: nil,
+                                             id: 11) }
+
+    before(:each) do
+      store_endpoint.stub(:get).and_return(parsed_response)
+    end
+
+    it "gets all the existing webhooks" do
+      store_endpoint.should_receive(:get).with('/webhooks')
+      subject.registered_webhooks
+    end
+
+    it "returns the existing webhooks" do
+      subject.registered_webhooks.should == existing_webhooks
+    end
+  end
+
+  describe "#webhook_id" do
+    let(:parsed_response) { mock("Parsed Response", :parsed => existing_webhooks) }
+    let(:existing_webhooks) { [] }
+    let(:existing_webhook) { mock("Webhook", address: 'url',
+                                             topic: 'pages/update',
+                                             resource_id: nil,
+                                             id: 11) }
+    let(:webhook) { mock("Webhook", address: 'url',
+                                    topic: 'pages/update',
+                                    resource_id: nil) }
+
+    before(:each) do
+      store_endpoint.stub(:get).and_return(parsed_response)
+    end
+
+    it "gets all the existing webhooks" do
+      store_endpoint.should_receive(:get).with('/webhooks')
+      subject.webhook_id(webhook)
+    end
+
+    context "one of the returned webhooks the webhook we already have" do
+      let(:existing_webhooks) { [existing_webhook] }
+
+      it "returns true" do
+        subject.webhook_id(webhook).should == 11
+      end
+    end
+
+    context "the webhook we want is not registered" do
+      it "returns false" do
+        subject.webhook_id(webhook).should == nil
+      end
+    end
+  end
+end

data/spec/crystal_api/webhook_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe CrystalApi::Webhook do
+  describe ".from_json" do
+    let(:json_hash) {{
+      "webhook" => {
+        "address"     => "https://example.com/cb",
+        "resource_id" => 123,
+        "topic"       => "pages/create",
+        "id"          => 11,
+        "only_catalog" => true
+      }
+    }}
+
+    subject { CrystalApi::Webhook.from_json(json_hash) }
+
+    its(:address)     { should == "https://example.com/cb" }
+    its(:resource_id) { should == 123 }
+    its(:topic)       { should == "pages/create" }
+    its(:id)          { should == 11 }
+    its(:only_catalog) { should == true }
+  end
+
+  describe "#as_json" do
+    subject { CrystalApi::Webhook.new(address: "https://example.com/cb",
+                                      resource_id: 123,
+                                      topic: "pages/create",
+                                      id: 1,
+                                      only_catalog: true) }
+
+    its(:as_json) { should == {
+      "webhook" => {
+        "address"     => "https://example.com/cb",
+        "resource_id" => 123,
+        "topic"       => "pages/create",
+        "id"          => 1,
+        "only_catalog" => true
+      }
+    }}
+
+    describe "except key" do
+      it "ignores the key expected" do
+        subject.as_json(:except => [:id]).should == {
+          "webhook" => {
+            "address"     => "https://example.com/cb",
+            "resource_id" => 123,
+            "topic"       => "pages/create",
+            "only_catalog" => true
+          }
+        }
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,25 @@
+require_relative '../lib/crystal_api'
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+
+  require 'webmock/rspec'
+  require_relative 'support/attribute_examples'
+  require_relative 'support/vcr'
+
+  # in RSpec 3 this will no longer be necessary.
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+end

data/spec/support/attribute_examples.rb

@@ -0,0 +1,77 @@
+shared_examples_for "integer attribute" do
+  context "string argument" do
+    subject { CrystalApi::Variant.new("#{attribute}" => "5") }
+
+    it "parses as integer" do
+      subject.send(attribute).should == 5
+    end
+  end
+
+  context "integer argument" do
+    subject { CrystalApi::Variant.new("#{attribute}" => 5) }
+
+    it "parses as integer" do
+      subject.send(attribute).should == 5
+    end
+  end
+end
+
+shared_examples_for "string attribute" do
+  context "string argument" do
+    subject { CrystalApi::Variant.new("#{attribute}" => "str") }
+
+    it "parses as string" do
+      subject.send(attribute).should == "str"
+    end
+  end
+end
+
+shared_examples_for "boolean attribute" do
+  context "argument 'true'" do
+    subject { CrystalApi::Variant.new("#{attribute}" => "true") }
+
+    it "parses as boolean" do
+      subject.send(attribute).should == true
+    end
+  end
+
+  context "argument 'false'" do
+    subject { CrystalApi::Variant.new("#{attribute}" => "false") }
+
+    it "parses as boolean" do
+      subject.send(attribute).should == false
+    end
+  end
+
+  context "argument '1'" do
+    subject { CrystalApi::Variant.new("#{attribute}" => "1") }
+
+    it "parses as boolean" do
+      subject.send(attribute).should == true
+    end
+  end
+
+  context "argument '0'" do
+    subject { CrystalApi::Variant.new("#{attribute}" => "0") }
+
+    it "parses as boolean" do
+      subject.send(attribute).should == false
+    end
+  end
+
+  context "argument true" do
+    subject { CrystalApi::Variant.new("#{attribute}" => true) }
+
+    it "parses as boolean" do
+      subject.send(attribute).should == true
+    end
+  end
+
+  context "argument false" do
+    subject { CrystalApi::Variant.new("#{attribute}" => false) }
+
+    it "parses as boolean" do
+      subject.send(attribute).should == false
+    end
+  end
+end