mad_cart 0.0.1

data/spec/lib/configuration_spec.rb

@@ -0,0 +1,52 @@
+require "spec_helper"
+
+describe "configuration" do
+
+  # use a clean instance for each test
+  before(:each) do
+    clear_config
+  end
+
+  describe "stores" do
+
+    it "does not require store to be added if credentials are passed to constructor" do
+      lambda{ MadCart::Store::BigCommerce.new({:api_key => 'a_fake_key', :store_url => '/path/to/store', :username => 'bob'}) }.should_not raise_error
+    end
+
+    it "allows config values to be set for a store" do
+      config_data = {:arbitrary => 'data'}
+      MadCart.configure do |config|
+        config.add_store :big_commerce, config_data
+      end
+
+      MadCart.config.big_commerce.should == config_data
+    end
+
+    it "gives returns nil if there's no config" do
+      MadCart.config.missing_store.should be_nil
+    end
+
+  end
+
+  describe "models" do
+    it "allows custom attribute names to be set" do
+      lambda {
+        MadCart.configure do |config|
+          config.attribute_map :products, {"name" => "title"}
+        end
+      }.should_not raise_error
+
+      MadCart.config.attribute_maps["products"].should == {"name" => "title"}
+    end
+
+    it "allows additional attributes to be included in models" do
+      MadCart.configure do |config|
+        config.include_attributes :products => [:external_id, :url]
+      end
+
+      MadCart.config.included_attributes[:products].should == [:external_id, :url]
+    end
+
+  end
+
+end

data/spec/lib/mad_cart_spec.rb

@@ -0,0 +1,25 @@
+require "spec_helper"
+
+describe MadCart do
+  
+  it "allows configuration" do
+    MadCart.configure do |config|
+      config.should be_a(MadCart::Configuration)
+      config.should be_a(Singleton)
+    end
+  end
+  
+  it "provides config values" do
+    MadCart.config.should be_a(MadCart::Configuration::Data)
+  end
+  
+  it "complains when the #config getter is used to set config values" do
+    lambda do
+      MadCart.config {|config| config.add_store :big_commerce }
+    end.should raise_error(ArgumentError, "MadCart.config does not support blocks. Use MadCart.configure to set config values.")
+  end
+  
+  it "complains if #configure is used incorrectly" do
+    lambda { MadCart.configure }.should raise_error(ArgumentError, "MadCart.configure requires a block argument.")
+  end  
+end

data/spec/lib/model/base_spec.rb

@@ -0,0 +1,49 @@
+require "spec_helper"
+
+describe MadCart::Store::Base do
+  before(:each) do
+    clear_config
+    Object.send(:remove_const, :MyModel) if Object.const_defined?(:MyModel)
+    class MyModel
+      include MadCart::Model::Base
+      required_attributes :name, :description
+    end
+  end
+
+  describe "attributes" do
+    it "can be configured to include additional attributes" do
+      MadCart.configure do |config|
+        config.include_attributes :my_models => [:external_id, :url]
+      end
+      
+      o = MyModel.new(:name => 'whiskey', :description => 'tasty', :external_id => 2, :url => 'path/to/whiskey', :discarded => 'property')
+      o.attributes.should == {"name" => 'whiskey', "description" => 'tasty', "external_id" => 2, "url" => 'path/to/whiskey'}
+    end
+    
+    it "includes mapped attributes" do
+      MadCart.configure do |config|
+        config.attribute_map :my_models, :old_name => :new_name
+      end
+      
+      o = MyModel.new(:name => 'whiskey', :description => 'tasty', :discarded => 'property', :old_name => 'is included')
+      o.attributes.should == {"name" => 'whiskey', "description" => 'tasty', "new_name" => 'is included'}
+    end
+    
+    it "allows two sources to map to the same model" do
+      MadCart.configure do |config|
+        config.include_attributes :my_models => [:external_id]
+        config.attribute_map :my_models, :id => :external_id
+      end
+      
+      source_a = {:name => 'whiskey', :description => 'tasty', :discarded => 'property', :id => 'has been renamed'}
+      source_b = {:name => 'whiskey', :description => 'tasty', :discarded => 'property', :external_id => 'is included'}
+      
+      model_a = MyModel.new(source_a)
+      model_a.attributes.should == {"name" => 'whiskey', "description" => 'tasty', "external_id" => 'has been renamed'}
+      
+      model_b = MyModel.new(source_b)
+      model_b.attributes.should == {"name" => 'whiskey', "description" => 'tasty', "external_id" => 'is included'}
+    end
+  end
+
+end

data/spec/lib/model/customer_spec.rb

@@ -0,0 +1,58 @@
+require "spec_helper"
+
+describe MadCart::Model::Customer do
+
+  before(:each) do
+    clear_config
+  end
+
+  it "returns the default attributes" do
+    attrs = {"first_name" => 'Bob', "last_name" => 'Sagat', "email" => 'bob@sagat.com'}
+    c = MadCart::Model::Customer.new(attrs)
+
+    c.attributes.should eql(attrs)
+  end
+
+  it "allows attributes to be overwritten" do
+    MadCart.configure do |config|
+      config.attribute_map :customers, {:first_name => :name}
+    end
+
+    c = MadCart::Model::Customer.new(:first_name => 'Bob', :last_name => 'Sagat', :email => 'bob@sagat.com')
+
+    c.attributes.should eql({"name" => 'Bob', "last_name" => 'Sagat', "email" => 'bob@sagat.com'})
+  end
+
+  it "exposes all additional attributes provided by the api" do
+    c = MadCart::Model::Customer.new("first_name" => 'Bob', "last_name" => 'Sagat', "email" => 'bob@sagat.com', "with" => 'some', "additional" => 'fields' )
+
+    c.additional_attributes.should eql({"with" => 'some', "additional" => 'fields'})
+  end
+
+  describe "validation" do
+
+    before(:each) do
+      @args = {:first_name => 'first_name',
+               :last_name => 'last_name',
+               :email => 'email'
+      }
+    end
+
+    it "requires first_name" do
+      @args.delete(:first_name)
+      lambda{ MadCart::Model::Customer.new(@args)  }.should raise_error(ArgumentError)
+    end
+
+    it "requires last_name" do
+      @args.delete(:last_name)
+      lambda{ MadCart::Model::Customer.new(@args)  }.should raise_error(ArgumentError)
+    end
+
+    it "requires email" do
+      @args.delete(:email)
+      lambda{ MadCart::Model::Customer.new(@args)  }.should raise_error(ArgumentError)
+    end
+
+  end
+
+end

data/spec/lib/model/product_spec.rb

@@ -0,0 +1,74 @@
+require "spec_helper"
+
+describe MadCart::Model::Product do
+
+  before(:each) do
+    clear_config
+  end
+
+  it "returns the default attributes" do
+    extra_attrs = {"external_id" => 'id', "price" => '12USD',
+                   "url" => 'path/to/product', "currency_code" => 'ZAR',
+                   "square_image_url" => 'path/to/square/image'}
+    default_attrs = {"name" => "product name", "description" => 'product description',
+                     "image_url" => 'path/to/image'}
+
+    c = MadCart::Model::Product.new(default_attrs.merge(extra_attrs))
+
+    c.attributes.should eql(default_attrs)
+  end
+
+  it "allows attribute names to be overwritten" do
+    MadCart.configure do |config|
+      config.attribute_map :products, {:square_image_url => :thumbnail,
+                                      :name => :title}
+    end
+
+    attrs = {"description" => 'product description',
+             "image_url" => 'path/to/image'}
+
+    c = MadCart::Model::Product.new(attrs.merge(:name => "product name", :square_image_url => 'path/to/square/image'))
+
+    c.attributes.should eql(attrs.merge("title" => "product name",
+                                        "thumbnail" => 'path/to/square/image'))
+  end
+
+  it "exposes all additional attributes provided by the api" do
+    attrs = {"name" => "product name", "description" => 'product description',
+             "image_url" => 'path/to/image'}
+
+    c = MadCart::Model::Product.new(attrs.merge(:with => 'some', :additional => 'fields'))
+
+    c.additional_attributes.should eql({"with" => 'some', "additional" => 'fields'})
+  end
+
+  describe "validation" do
+
+    before(:each) do
+      @args = {:name => 'name',
+               :external_id => 'external_id',
+               :description => 'description',
+               :price => 'price',
+               :url => 'url',
+               :currency_code => 'currency_code',
+               :image_url => 'image_url',
+               :squre_image_url => 'square_image_url'
+      }
+    end
+
+    it "requires name" do
+      @args.delete(:name)
+      lambda{ MadCart::Model::Product.new(@args)  }.should raise_error(ArgumentError)
+    end
+
+    it "requires description" do
+      @args.delete(:description)
+      lambda{ MadCart::Model::Product.new(@args)  }.should raise_error(ArgumentError)
+    end
+
+    it "requires image_url" do
+      @args.delete(:image_url)
+      lambda{ MadCart::Model::Product.new(@args)  }.should raise_error(ArgumentError)
+    end
+  end
+end

data/spec/lib/store/base_spec.rb

@@ -0,0 +1,231 @@
+require "spec_helper"
+
+describe MadCart::Store::Base do
+  before(:each) do
+    Object.send(:remove_const, :MyStore) if Object.const_defined?(:MyStore)
+    class MyStore; include MadCart::Store::Base; end
+    class TestResult; end
+  end
+
+  describe "connection" do
+    it "adds a create_connection_with method" do
+      MyStore.should respond_to(:create_connection_with)
+    end
+
+    it "accepts a method reference" do
+      MyStore.class_eval do
+        create_connection_with :connection_method
+
+        def connection_method(args={})
+          return TestResult
+        end
+      end
+
+      MyStore.new.connection.should == TestResult
+    end
+
+    it "accepts a proc" do
+      MyStore.class_eval do
+        create_connection_with Proc.new {|args| TestResult }
+      end
+
+      MyStore.new.connection.should == TestResult
+    end
+
+    it "raises an error if any required connection arguments are not present" do
+      MyStore.class_eval do
+        create_connection_with Proc.new { }, :requires => [:api_key, :username]
+      end
+
+      lambda { MyStore.new(:api_key => 'key').connection }.should raise_error(ArgumentError, "Missing connection arguments: username")
+    end
+
+    it "retrieves configured connection arguments" do
+      class MyStore
+        create_connection_with Proc.new { }, :requires => [:several, :args]
+      end
+
+      MadCart.configure do |config|
+        config.add_store :my_store, {:several => 'of', :args => 'yes?'}
+      end
+
+      lambda { MyStore.new().connection }.should_not raise_error
+    end
+
+    it "retrieves a combination of configured and initialised connection arguments" do
+      class MyStore
+        create_connection_with Proc.new { }, :requires => [:several, :args]
+      end
+
+      MadCart.configure do |config|
+        config.add_store :my_store, {:several => 'only'}
+      end
+
+      lambda { MyStore.new(:args => 'too').connection }.should_not raise_error
+    end
+  end
+
+  describe "fetch" do
+    it "adds a fetch method" do
+      MyStore.should respond_to(:fetch)
+    end
+
+    it "accepts a method reference" do
+      MyStore.class_eval do
+        fetch :products, :with => :fetch_method
+
+        def fetch_method
+          return [{:some => 'attrs'}]
+        end
+      end
+
+      result = double(MadCart::Model::Product)
+      MadCart::Model::Product.should_receive(:new).with({:some => 'attrs'}).and_return(result)
+      MyStore.new.products.should == [result]
+    end
+
+    it "accepts a proc" do
+      MyStore.class_eval do
+        fetch :products, :with => Proc.new { [{:some => 'attrs'}, {:some => 'attrs'}] }
+      end
+
+      result = double(MadCart::Model::Product)
+      MadCart::Model::Product.should_receive(:new).twice.with({:some => 'attrs'}).and_return(result)
+      MyStore.new.products.should == [result, result]
+    end
+
+    it "converts hashes into instances of the mad cart model" do
+      attrs = {"external_id" => 'id', "name" => "product name", "description" => 'product description', "price" => '12USD',
+             "url" => 'path/to/product', "currency_code" => 'ZAR',
+             "image_url" => 'path/to/image', "square_image_url" => 'path/to/square/image'}
+      MyStore.class_eval do
+        fetch :products, :with => Proc.new { [attrs, attrs] }
+      end
+
+      MyStore.new.products.each{|p| p.should be_a(MadCart::Model::Product) }
+    end
+
+    it "returns instances of the mad cart model if the fetch method returns them" do
+      attrs = {"external_id" => 'id', "name" => "product name", "description" => 'product description', "price" => '12USD',
+             "url" => 'path/to/product', "currency_code" => 'ZAR',
+             "image_url" => 'path/to/image', "square_image_url" => 'path/to/square/image'}
+      MyStore.class_eval do
+        fetch :products, :with => Proc.new { [MadCart::Model::Product.new(attrs), MadCart::Model::Product.new(attrs)] }
+      end
+
+      MyStore.new.products.each{|p| p.should be_a(MadCart::Model::Product) }
+    end
+
+    it "returns instances of the mad cart model if the format method returns them" do
+      attrs = {"external_id" => 'id', "name" => "product name", "description" => 'product description', "price" => '12USD',
+             "url" => 'path/to/product', "currency_code" => 'ZAR',
+             "image_url" => 'path/to/image', "square_image_url" => 'path/to/square/image'}
+      MyStore.class_eval do
+        fetch :products, :with => Proc.new { [attrs, attrs] }
+        format :products, :with => Proc.new {|p| MadCart::Model::Product.new(p) }
+      end
+
+      MyStore.new.products.each{|p| p.should be_a(MadCart::Model::Product) }
+    end
+
+    it "can be configured to retrieve additional attributes" do
+      MadCart.configure do |config|
+        config.include_attributes :products => [:external_id]
+      end
+
+      MyStore.class_eval do
+        fetch :products, :with => Proc.new {   }
+      end
+    end
+  end
+
+  describe "format" do
+    it "adds a format method" do
+      MyStore.should respond_to(:format)
+    end
+
+    it "accepts a method reference" do
+      MyStore.class_eval do
+        fetch :products, :with => Proc.new { [:one => 1] }
+        format :products, :with => :format_method
+
+        def format_method(product)
+          return product
+        end
+      end
+
+      store = MyStore.new
+      store.should_receive(:format_method).with(:one => 1).and_return(double(MadCart::Model::Product))
+      store.stub(:ensure_model_format)
+      store.products
+    end
+
+    it "accepts a proc" do
+      MyStore.class_eval do
+        fetch :products, :with => Proc.new { [1] }
+        format :products, :with => Proc.new {|product| product.to_s }
+      end
+
+      store = MyStore.new
+      store.should_receive(:ensure_model_format).with(:products, ["1"])
+      store.products
+    end
+  end
+
+  describe "initialize" do
+
+    it "raises an exception on connection if initialize doesn't store the required connection args" do
+      class MyStore
+        create_connection_with Proc.new { }, :requires => [:args]
+
+        def initialize
+        end
+      end
+
+      o = MyStore.new
+      lambda { o.connection }.should raise_error(MadCart::Store::SetupError,
+          "It appears MyStore has overrided the default MadCart::Base initialize method. " +
+          "That's fine, but please store any required connection arguments as @init_args " +
+          "for the #connection method to use later. Remember to call #after_initialize " +
+          "in your initialize method should you require it.")
+    end
+  end
+
+  describe "after_initialize" do
+    it "adds an after_initialize method" do
+      MyStore.should respond_to(:after_initialize)
+    end
+
+    it "accepts a method reference" do
+      MyStore.class_eval do
+        after_initialize :init_method
+        create_connection_with :connect_method
+
+        def init_method(*args)
+          @my_instance_var = args.first[:connection]
+        end
+
+        def connect_method(*args)
+          return @my_instance_var
+        end
+      end
+
+      MyStore.new(:connection => TestResult).connection.should == TestResult
+    end
+
+    it "accepts a proc" do
+      MyStore.class_eval do
+        after_initialize Proc.new {|arg| TestResult.new }
+        create_connection_with :connect_method
+
+        def connect_method(*args)
+          return @my_instance_var
+        end
+      end
+
+      TestResult.should_receive(:new)
+
+      MyStore.new(:connection => TestResult)
+    end
+  end
+end

data/spec/lib/store/big_commerce_spec.rb

@@ -0,0 +1,117 @@
+require "spec_helper"
+
+describe MadCart::Store::BigCommerce do
+
+  let(:valid_credentials) {
+    { :api_key => '0ff0e3939f5f160f36047cf0caa6f699fe24bdeb',
+      :store_url => 'store-cr4wsh4.mybigcommerce.com',
+      :username => 'admin' }
+  }
+
+  describe "store" do
+
+    it "expects to be instantiated with an api key, username and store url" do
+      lambda { MadCart::Store::BigCommerce.new(:username => 'test', :store_url => 'test').connection }.should raise_error(ArgumentError)
+      lambda { MadCart::Store::BigCommerce.new(:api_key => 'test', :username => 'test', :store_url => 'test').connection }.should_not raise_error
+    end
+
+    it "authenticates via basic auth" do
+      connection = Faraday.new
+      Faraday.stub(:new).and_return(connection)
+
+      connection.should_receive(:basic_auth).with('username', 'api_key')
+
+      MadCart::Store::BigCommerce.new(:api_key => 'api_key', :username => 'username', :store_url => 'url').connection
+    end
+
+  end
+
+  describe "products" do
+
+    context "retrieval" do
+
+      it "returns all products" do
+        VCR.use_cassette('big_commerce') do
+          api = MadCart::Store::BigCommerce.new(valid_credentials)
+
+          api.products.size.should == 45
+
+          first_product = api.products.first
+
+          first_product.should be_a(MadCart::Model::Product)
+          first_product.name.should_not be_nil
+          first_product.description.should_not be_nil
+          first_product.image_url.should_not be_nil
+        end
+      end
+
+      it "returns an empty array when there are no products" do
+        VCR.use_cassette('big_commerce_no_records') do
+          api = MadCart::Store::BigCommerce.new(valid_credentials)
+          api.products.should == []
+        end
+      end
+
+    end
+
+    context "count" do
+
+      it "returns how many products there are" do
+        VCR.use_cassette('big_commerce') do
+          api = MadCart::Store::BigCommerce.new(valid_credentials)
+          api.products_count.should == 45
+        end
+      end
+
+    end
+
+  end
+
+  describe "customers" do
+    context "retrieval" do
+
+      it "returns all customers" do
+        VCR.use_cassette('big_commerce') do
+          api = MadCart::Store::BigCommerce.new(valid_credentials)
+
+          api.customers.size.should be > 0
+          api.customers.first.should be_a(MadCart::Model::Customer)
+        end
+      end
+
+      it "returns an empty array whern there are no customers" do
+        VCR.use_cassette('big_commerce_no_records') do
+          api = MadCart::Store::BigCommerce.new(valid_credentials)
+
+          api.customers.should eql([])
+        end
+      end
+
+    end
+
+    describe "validating credentials" do
+
+      it "succeeds if it can get time.json from big commerce" do
+        VCR.use_cassette('big_commerce') do
+          api = MadCart::Store::BigCommerce.new(valid_credentials)
+
+          api.should be_valid
+        end
+      end
+
+      it "fails if it cannot get time.json from big commerce" do
+        VCR.use_cassette('big_commerce') do
+          api = MadCart::Store::BigCommerce.new(
+            :api_key => 'an-invalid-key',
+            :store_url => 'store-cr4wsh4.mybigcommerce.com',
+            :username => 'admin'
+          )
+
+          api.should_not be_valid
+        end
+      end
+
+    end
+  end
+
+end