vend 0.0.4

data/spec/vend/http_client_spec.rb

@@ -0,0 +1,129 @@
+require 'spec_helper'
+
+describe Vend::HttpClient do
+
+  let(:base_url)  { "https://foo/bar/" }
+  let(:username)  { "username" }
+  let(:password)  { "password" }
+  let(:options)   {
+    {:base_url => base_url, :username => username, :password => password}
+  }
+
+  subject {
+    described_class.new(options)
+  }
+
+  it_should_behave_like "it has a logger"
+
+  its(:base_url) { should == base_url }
+  its(:username) { should == username }
+  its(:password) { should == password }
+
+  describe "#verify_ssl?" do
+    its(:verify_ssl) { should be_true }
+
+    context "when overridden in the options" do
+      subject { described_class.new(options.merge(:verify_ssl => false)) }
+    end
+  end
+
+  describe "#get_http_connection" do
+    let(:http)        { mock("http") }
+    let(:verify_mode) { mock("verify_mode") }
+    let(:host)        { "foo" }
+    let(:port)        { 42 }
+
+    before do
+      subject.stub(:verify_mode => verify_mode)
+      http.should_receive(:use_ssl=).with(true)
+      http.should_receive(:verify_mode=).with(verify_mode)
+      Net::HTTP.stub(:new).with(host, port) { http }
+    end
+
+    it "returns the http_connection" do
+      subject.get_http_connection(host, port).should == http
+    end
+  end
+
+  describe "#verify_mode" do
+
+    context "when verify_ssl? is true" do
+      before do
+        subject.stub(:verify_ssl? => true)
+      end
+      its(:verify_mode) { should == OpenSSL::SSL::VERIFY_PEER }
+    end
+
+    context "when verify_ssl? is false" do
+      before do
+        subject.stub(:verify_ssl? => false)
+      end
+      its(:verify_mode) { should == OpenSSL::SSL::VERIFY_NONE }
+    end
+
+  end
+
+  describe "#request" do
+
+    context "when using invalid credentials" do
+
+      let(:username)  { "invalid" }
+
+      it "raises an error" do
+        stub_request(:get, "https://invalid:password@foo/bar/products").
+          to_return(:status => 401)
+
+        expect {
+          subject.request('products')
+        }.to raise_error(Vend::Unauthorized)
+      end
+
+    end
+
+    it "throws an error when an invalid request is made" do
+      stub_request(:get, "https://username:password@foo/bar/invalid").
+        to_return(:status => 404, :body => '{"foo":"bar"}', :headers => {})
+
+      expect {
+        subject.request('invalid')
+      }.to raise_error(Vend::HTTPError)
+    end
+
+    it "returns parsed JSON" do
+      stub_request(:get, "https://username:password@foo/bar/bun").
+        to_return(:status => 200, :body => '{"foo":"bar"}', :headers => {})
+      subject.request("bun").should == {"foo" => "bar"}
+    end
+
+    it "returns nil if the response was empty" do
+      stub_request(:get, "https://username:password@foo/bar/bun").
+        to_return(:status => 200, :body => '', :headers => {})
+      subject.request("bun").should be_nil
+    end
+    it "allows us to specify HTTP method" do
+      stub_request(:post, "https://username:password@foo/bar/foo").
+        to_return(:status => 200, :body => '{"foo":"bar"}', :headers => {})
+
+      response = subject.request('foo', :method => :post)
+      response.should == {"foo" => "bar"}
+    end
+
+    it "allows us to set a request body" do
+      stub_request(:post, "https://username:password@foo/bar/foo").
+        with(:body => "{\"post\":\"data\"}").
+        to_return(:status => 200, :body => '{"foo":"bar"}', :headers => {})
+
+      response = subject.request('foo', :method => :post, :body => '{"post":"data"}')
+      response.should == {"foo" => "bar"}
+    end
+
+    it "allows us to specify url parameters" do
+      stub_request(:get, "https://username:password@foo/bar/foo?foo=bar&baz=baloo&flum%5B0%5D=blob&flum%5B1%5D=splat").
+        to_return(:status => 200, :body => '{"foo":"bar"}', :headers => {})
+
+      response = subject.request('foo', :url_params => {:foo => "bar", :baz => "baloo", :flum => ["blob","splat"]})
+      response.should == {"foo" => "bar"}
+    end
+
+  end
+end

data/spec/vend/null_logger_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe Vend::NullLogger do
+  it_should_behave_like "a logger"
+end

data/spec/vend/pagination_info_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe Vend::PaginationInfo do
+
+  subject { described_class.new(response) }
+
+  let(:response)  { mock("response") }
+
+  its(:response)  { should == response }
+
+  context "when response has pagination info" do
+    let(:response)  {
+      {
+        "pagination" => {
+          "results"   => 7461,
+          "page"      => 41,
+          "page_size" => 100,
+          "pages"     => 75 
+        }
+      }
+    }
+
+    its(:pages) { should == 75 }
+    its(:page)  { should == 41 }
+    it { should be_paged }
+
+    describe "#last_page?" do
+
+      it { should_not be_last_page }
+
+      context "when page is equal to pages" do
+        before do
+          subject.stub(:page => 42, :pages => 42)
+        end
+        it { should be_last_page }
+      end
+
+    end
+  end
+
+  context "when response does not have pagination info" do
+    let(:response)  { Hash.new }
+    its(:pages) { should == 1 }
+    its(:page)  { should == 1 }
+    it { should be_last_page }
+    it { should_not be_paged }
+  end
+end

data/spec/vend/resource/register_sale_product_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Vend::Resource::RegisterSaleProduct do
+  let(:attrs) { mock("attrs") }
+
+  subject { described_class.new(attrs) }
+
+  its(:attrs) { should == attrs }
+
+  describe "provides an attr reader for the attributes in attrs" do
+    let(:attr1) { mock("attr1") }
+
+    let(:attrs) { 
+      { 
+        "attr1" => attr1
+      }
+    }
+
+    it "responds to attr1" do
+      subject.send(:attr1).should == attr1
+    end
+
+    it "does not respond to attr2" do
+      lambda { subject.send(:attr2) }.should raise_error NoMethodError
+    end
+  end
+end

data/spec/vend/resource/register_sale_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Vend::Resource::RegisterSale do
+
+  subject { described_class.new(nil, {}) }
+
+  describe "#register_sale_products" do
+    let(:register_sale_product) { mock("register sale product") }
+    let(:raw_register_sale_product) { mock("raw register sale prodcut") }
+
+    before do
+      subject.stub(:attrs) { 
+        { "register_sale_products" => [raw_register_sale_product] } 
+      }
+      Vend::Resource::RegisterSaleProduct.stub(:new).with(raw_register_sale_product) {
+        register_sale_product 
+      }
+    end
+
+    it "returns all the register sale products" do
+      subject.register_sale_products.should == [register_sale_product]
+    end
+  end
+end

data/spec/vend/resource_collection_spec.rb

@@ -0,0 +1,312 @@
+require 'spec_helper'
+
+describe Vend::ResourceCollection do
+
+  let(:client)        { mock("client") }
+  let(:target_class)  { mock("target_class") }
+  let(:endpoint)      { "endpoint" }
+  let(:request_args)  { mock("request_args") }
+
+  subject { described_class.new(client, target_class, endpoint, request_args) }
+
+  its(:client)        { should == client }
+  its(:target_class)  { should == target_class }
+  its(:endpoint)      { should == endpoint }
+  its(:scopes)        { should == [] }
+
+  describe "#request_args" do
+
+    its(:request_args)  { should == request_args }
+
+    context "when not set in initialize" do
+      subject {
+        described_class.new(client, target_class, endpoint)
+      }
+      its(:request_args)  { should == {} }
+    end
+
+  end
+
+  describe "#each" do
+
+    let(:member_one)  { mock("member_one") }
+    let(:member_two)  { mock("member_two") }
+    let(:json)        { mock("json") }
+    let(:next_page)   { mock("next_page") }
+
+    before do
+      target_class.should_receive(:build_from_json).with(client, next_page) {
+        [member_one, member_two]
+      }
+      client.stub(:request).with(endpoint, request_args) { json }
+      subject.stub(:get_next_page) { next_page }
+      subject.stub(:last_page?).and_return(false, true)
+    end
+
+    it "yields each member and returns self" do
+      member_one.should_receive(:ping!)
+      member_two.should_receive(:ping!)
+      subject.each do |member|
+        member.ping!
+      end.should == subject
+    end
+
+  end
+
+  describe "#last_page?" do
+
+    context "when pagination is set" do
+      let(:value)       { mock("value") }
+      let(:pagination)  { mock("pagination", :last_page? => value) }
+      before do
+        subject.stub(:pagination => pagination)
+      end
+      it "delegates to #pagination" do
+        subject.last_page?.should == value
+      end
+    end
+
+    context "when pagination is nil" do
+      it { should_not be_last_page }
+    end
+
+  end
+
+  describe "#paged?" do
+
+    context "when pagination is set" do
+      let(:value)       { mock("value") }
+      let(:pagination)  { mock("pagination", :paged? => value) }
+      before do
+        subject.stub(:pagination => pagination)
+      end
+      it "delegates to #pagination" do
+        subject.paged?.should == value
+      end
+    end
+
+    context "when pagination is nil" do
+      specify do
+        subject.paged?.should be_false
+      end
+    end
+
+  end
+
+  [:pages, :page].each do |method|
+    describe method do
+      let(:value)       { mock("value") }
+      let(:pagination)  { mock("pagination", method => value) }
+      before do
+        subject.stub(:pagination => pagination)
+      end
+      it "delegates to #pagination" do
+        subject.send(method).should == value
+      end
+    end
+  end
+
+  describe "#scope" do
+    let(:value)   { mock("value") }
+    let(:scope)   { mock("scope") }
+    let(:scopes)  { mock("scopes") }
+
+    context "when scope is not already present" do
+      before do
+        subject.stub(:has_scope?).with(:name) { false }
+        subject.stub(:scopes => scopes)
+        Vend::Scope.stub(:new).with(:name, value) { scope }
+        scopes.should_receive(:<<).with(scope)
+      end
+      it "returns self" do
+        subject.scope(:name, value).should == subject
+      end
+    end
+
+    context "when already scoped" do
+      before do
+        subject.stub(:has_scope?).with(:name) { true }
+      end
+      it "raises and AlreadyScopedError" do
+        lambda do
+          subject.scope(:name, value)
+        end.should raise_exception(Vend::ResourceCollection::AlreadyScopedError)
+      end
+    end
+  end
+
+  describe "#has_scope?" do
+    context "when scope is not present" do
+      it { should_not have_scope(:name) }
+    end
+    context "when scope is present" do
+      let(:scope) { mock("scope", :name => :name) }
+      before do
+        subject.stub(:scopes => [scope])
+      end
+      it { should have_scope(:name) }
+    end
+  end
+
+  describe "#accepts_scope?" do
+    let(:value) { mock("value") }
+    before do
+      target_class.stub(:accepts_scope?).with(:name)  { value }
+    end
+    it "delegates to target_class" do
+      subject.accepts_scope?(:name).should == value
+    end
+  end
+
+  describe "#method_missing" do
+
+    let(:value) { mock("value") }
+
+    context "when the method name is a valid scope name" do
+
+      before do
+        subject.stub(:accepts_scope?).with(:foo) { true }
+      end
+
+      it { should respond_to(:foo) }
+
+      it "adds the relevant scope if it accepts a scope for the method name" do
+        subject.should_receive(:scope).with(:foo, value) { subject }
+        subject.foo(value).should == subject
+      end
+
+    end
+
+    context "when the method name is not a valid scope name" do
+
+      before do
+        subject.stub(:accepts_scope?).with(:foo) { false }
+      end
+
+      it { should_not respond_to(:foo) }
+
+      it "raises method missing" do
+        lambda do
+          subject.foo(value)
+        end.should raise_exception(NoMethodError)
+      end
+
+    end
+
+  end
+
+  describe "#url" do
+
+    let(:endpoint_with_scopes) { "endpoint_with_scopes" }
+
+    before do
+      subject.stub(:endpoint_with_scopes => endpoint_with_scopes)
+      subject.should_receive(:increment_page)
+    end
+
+    its(:url) { should == endpoint_with_scopes }
+  end
+
+  describe "#endpoint_with_scopes" do
+    
+    context "when there are no scopes" do
+      its(:endpoint_with_scopes) { should == endpoint }
+    end
+
+    context "when there are scopes" do
+      let(:scope1) { "scope1" }
+      let(:scope2) { "scope2" }
+      let(:scopes) { [scope1, scope2] }
+      before do
+        subject.stub(:scopes => scopes)
+      end
+
+      its(:endpoint_with_scopes) { should == endpoint + scopes.join}
+    end
+  end
+
+  describe "#increment_page" do
+
+    context "when not paged" do
+
+      before do
+        subject.stub(:paged? => false)
+      end
+
+      its(:increment_page) { should be_nil }
+
+    end
+
+    context "when paged" do
+
+      let(:page_scope)  { mock("page_scope", :value => 1) }
+
+      before do
+        subject.stub(:paged? => true)
+        subject.stub(:page => 1)
+        subject.should_receive(:get_or_create_page_scope) { page_scope }
+        page_scope.should_receive(:value=).with(2) { 2 }
+      end
+
+      its(:increment_page) { should == 2 }
+
+    end
+
+  end
+
+  describe "#get_or_create_page_scope" do
+
+    let(:page_scope)  { mock("page_scope") }
+    let(:page)        { 1 }
+
+    before do
+      subject.stub(:page => page)
+      subject.should_receive(:get_scope).with(:page) { page_scope }
+    end
+
+    context "when scope is not present" do
+      before do
+        subject.stub(:has_scope?).with(:page) { false }
+        subject.should_receive(:scope).with(:page, page) { page_scope }
+      end
+      its(:get_or_create_page_scope)  { should == page_scope }
+    end
+
+    context "when scope is already present" do
+      before do
+        subject.stub(:has_scope?).with(:page) { true }
+      end
+      its(:get_or_create_page_scope)  { should == page_scope }
+    end
+  end
+
+  describe "#get_scope" do
+
+    let(:scope_name)  { :scope_name }
+    let(:scope)       { mock("scope", :name => scope_name) }
+
+    context "when scope is present" do
+
+      before do
+        subject.stub(:scopes => [scope])
+      end
+
+      specify do
+        subject.get_scope(scope_name).should == scope
+      end
+
+    end
+
+    context "when scope is not present" do
+      before do
+        subject.stub(:scopes => [])
+      end
+      specify do
+        lambda do
+          subject.get_scope(scope_name)
+        end.should raise_exception(Vend::ResourceCollection::ScopeNotFoundError)
+      end
+    end
+
+  end
+end