big_door 0.0.1

data/spec/big_door/client_spec.rb

@@ -0,0 +1,163 @@
+require 'spec_helper'
+
+module BigDoor 
+    describe Client do
+        context "fresh client object" do 
+            subject { BigDoor::Client.new( TEST_APP_SECRET, TEST_APP_KEY )  }
+            it { should be }
+            it { should be_a_instance_of( BigDoor::Client )}
+            it { should respond_to(:app_key).with(0).arguments }
+            it "Should return app_key assigned" do
+                subject.app_key.should == TEST_APP_KEY
+            end
+            
+            it { should respond_to(:app_secret).with(0).arguments }
+            it "Should return app_secret assigned" do
+                subject.app_secret.should == TEST_APP_SECRET
+            end
+
+            it { should respond_to(:app_host).with(0).arguments }
+            it "Should return default app_host" do
+                subject.app_host.should == 'http://api.bigdoor.com'
+            end
+            
+            describe "#get" do 
+                it { should respond_to(:get).with(1).arguments }
+                it { should respond_to(:get).with(2).arguments }
+                it "should return 9 predefined currency_type objects" do
+                    response = subject.get('currency_type')
+                    response.should be
+                    response.should be_a_instance_of( Array )
+                    response.length.should == 9
+                end
+            end
+
+            describe "#post" do
+                it { should respond_to(:post).with(3).arguments }
+                it "should create currency object" do
+                    currency = {
+                        'pub_title'            => 'Coins ',
+                        'pub_description'      => 'an example of the Purchase currency type',
+                        'end_user_title'       => 'Coins',
+                        'end_user_description' => 'can only be purchased',
+                        'currency_type_id'     => '1',
+                        'currency_type_title'  => 'Purchase',
+                        'exchange_rate'        => 900.00,
+                        'relative_weight'      => 2,
+                    }
+                    response = subject.post('currency', { 'format' => 'json' }, currency )
+                    response.should be
+                    response.should be_a_instance_of( Hash )
+                    response['pub_title'].should == 'Coins '
+                    response['pub_description'].should == 'an example of the Purchase currency type'
+                    response['id'].should be
+                    currency_id = response['id'].to_s
+                    currency_id.should =~ /[0-9]+/
+
+                    subject.delete('currency/%s' % currency_id )
+                end
+            end
+            describe "#put" do
+                it { should respond_to(:put).with(3).arguments }
+                it "should create and update currency object" do
+                    currency = {
+                        'pub_title'            => 'Coins ',
+                        'pub_description'      => 'an example of the Purchase currency type',
+                        'end_user_title'       => 'Coins',
+                        'end_user_description' => 'can only be purchased',
+                        'currency_type_id'     => '1',
+                        'currency_type_title'  => 'Purchase',
+                        'exchange_rate'        => 900.00,
+                        'relative_weight'      => 2,
+                    }
+                    response = subject.post('currency', { 'format' => 'json' }, currency )
+                    response.should be
+                    response.should be_a_instance_of( Hash )
+                    response['id'].should be
+                    currency_id = response['id'].to_s
+                    currency_id.should =~ /[0-9]+/
+
+                    currency['pub_title'] = 'Coins'
+                    currency.delete('token')
+                    response = subject.put('currency/%s' % currency_id, { 'format' => 'json' }, currency )
+                    response.should be
+                    response.should be_a_instance_of( Hash )
+                    response['pub_title'].should == 'Coins'
+                    response['pub_description'].should == 'an example of the Purchase currency type'
+                    subject.delete('currency/%s' % currency_id )
+                end
+            end
+            describe "#delete" do
+                it { should respond_to(:delete).with(2).arguments }
+                it "should create and delete currency object" do
+                    currency = {
+                        'pub_title'            => 'Coins ',
+                        'pub_description'      => 'an example of the Purchase currency type',
+                        'end_user_title'       => 'Coins',
+                        'end_user_description' => 'can only be purchased',
+                        'currency_type_id'     => '1',
+                        'currency_type_title'  => 'Purchase',
+                        'exchange_rate'        => 900.00,
+                        'relative_weight'      => 2,
+                    }
+                    response = subject.post('currency', { 'format' => 'json' }, currency )
+                    response.should be
+                    response.should be_a_instance_of( Hash )
+                    response['id'].should be
+                    currency_id = response['id'].to_s
+                    currency_id.should =~ /[0-9]+/
+
+                
+                    # FIXME check for exception    
+                    response = subject.delete('currency/%s' % currency_id )
+                    # check that zero objects left
+                end
+            end
+
+        end
+        describe "fresh client object with app_host set explictly" do
+            subject { BigDoor::Client.new( TEST_APP_SECRET, TEST_APP_KEY, 'http://localhost/') }
+            it "Should return app_host assigned" do
+                    subject.app_host.should == 'http://localhost/'
+            end
+        end    
+
+        context "fresh client object with fake keys" do
+            subject { BigDoor::Client.new( FAKE_APP_SECRET , FAKE_APP_KEY ) }
+            it { should respond_to(:generate_signature).with(2).arguments }
+            it "Should generate matching signature for 2 arguments" do
+                params = { 'time' => 1270503018.33  }
+                url = "/api/publisher/#{FAKE_APP_KEY}/transaction_summary"
+                signature = subject.generate_signature( url, params )
+                signature.should == '9d1550bb516ee2cc47d163b4b99f00e15c84b3cd32a82df9fd808aa0eb505f04'
+            end
+            it { should respond_to(:generate_signature).with(1).arguments }
+            it "Should generate matching signature for 1 argument" do
+                url = "/api/publisher/#{FAKE_APP_KEY}/transaction_summary"
+                signature = subject.generate_signature( url ) 
+                signature.should == 'fa5ae4f36a4d90abae0cbbe5fd3d59b73bae6638ff517e9c26be64569c696bcc'
+            end
+            it { should respond_to(:generate_signature).with(2).arguments }
+            it "Should generate matching signature for 2 argument and whitelisted param" do
+                url = "/api/publisher/#{FAKE_APP_KEY}/transaction_summary"
+                params = { 'format' => 'json', 'sig' => 'this_sig_is_fake!' }
+                signature = subject.generate_signature( url, params ) 
+                signature.should == 'fa5ae4f36a4d90abae0cbbe5fd3d59b73bae6638ff517e9c26be64569c696bcc'
+            end
+            it { should respond_to(:generate_signature).with(3).arguments }
+            it "Should generate matching signature for 3 argument and whitelisted param" do
+
+                url = "/api/publisher/#{FAKE_APP_KEY}/currency/1"
+
+                params = { 'format' => 'json', 'time' => '1270517162.52'};
+                payload = { 
+                    'end_user_description' => 'Testing signature generation.',
+                    'time'                 => '1270517162.52',
+                    'token'                => 'bd323c0ca7c64277ba2b0cd9f93fe463' 
+                }
+                signature = subject.generate_signature( url, params, payload ) 
+                signature.should == 'cd073723c4901b57466694f63a2b7746caf1836c9bcdd4f98d55357334c2de64'
+            end
+        end
+    end
+end

data/spec/big_door/currency_balance_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+module BigDoor 
+    describe CurrencyBalance do
+        before(:each) do
+            @client = BigDoor::Client.new( TEST_APP_SECRET, TEST_APP_KEY )
+        end
+        context "fresh CurrencyBalance object" do 
+            subject { BigDoor::CurrencyBalance.new  }
+            it { should be }
+            it { should be_a_instance_of( BigDoor::CurrencyBalance )}
+        end
+    end
+end

data/spec/big_door/currency_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+module BigDoor 
+    describe Currency do
+        before(:each) do
+            @client = BigDoor::Client.new( TEST_APP_SECRET, TEST_APP_KEY )
+        end
+        context "Currency class" do
+            it "Should respond to :all" do 
+                BigDoor::Currency.should respond_to(:all).with(1).arguments
+            end
+            it "Should load Array of Currencies at the beginning" do
+                currencies = BigDoor::Currency.all( @client )
+                currencies.should be_a_instance_of( Array )
+            end
+        end
+        context "fresh Currency object" do 
+            subject { BigDoor::Currency.new  }
+            it { should be }
+            it { should be_a_instance_of( BigDoor::Currency )}
+            it { should respond_to(:save).with(1).arguments }
+            it "Should save object successfully" do
+
+                subject.pub_title = 'Coins'
+                subject.pub_description = 'an example of the Purchase currency type'
+                subject.end_user_title = 'Coins'
+                subject.end_user_description = 'can only be purchased'
+                subject.currency_type_id = 1
+                subject.currency_type_title = 'Purchase'
+                subject.exchange_rate = 900
+                subject.relative_weight = 2
+
+                subject.save( @client )
+
+                should respond_to('resource_id').with(0).arguments
+                subject.resource_id.to_s.should =~ /\d+/
+                save_resource_id = subject.resource_id
+
+                should respond_to('resource_name').with(0).arguments
+                subject.resource_name.should == 'currency'
+
+                subject.pub_title = 'Banknotes'
+                subject.save( @client )
+                subject.resource_id.should == save_resource_id
+                subject.pub_title.should == 'Banknotes'
+
+                subject.resource_id = nil
+                subject.pub_title = nil
+
+                should respond_to('load').with(2).arguments
+                subject.load( @client, save_resource_id  )
+                
+                subject.resource_id.should == save_resource_id
+                subject.pub_title.should == 'Banknotes'
+
+                subject.pub_title = nil
+
+                should respond_to('load').with(1).arguments
+                subject.load( @client )
+                
+                subject.resource_id.should == save_resource_id
+                subject.pub_title.should == 'Banknotes'
+                
+                currencies = BigDoor::Currency.all( @client )
+                currencies.should be_a_instance_of( Array )
+                currencies.should_not be_empty
+
+                currencies[0].should be_a_instance_of( Currency )
+
+                should respond_to(:delete).with(1).arguments
+                subject.delete( @client )
+            end
+            it { should respond_to(:load).with(2).arguments }
+            it { should respond_to(:delete).with(2).arguments }
+            it "Should load Array of Currencies at the end" do
+                currencies = BigDoor::Currency.all( @client )
+                currencies.should be_a_instance_of( Array )
+            end
+        end
+    end
+end

data/spec/big_door/currency_type_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+module BigDoor 
+    describe CurrencyType do
+        before(:each) do
+            @client = BigDoor::Client.new( TEST_APP_SECRET, TEST_APP_KEY )
+        end
+        context "CurrencyType class" do
+            it "Should respond to :all" do 
+                BigDoor::CurrencyType.should respond_to(:all).with(1).arguments
+            end
+            it "Should load Array of Currency types at the beginning" do
+                currency_types = BigDoor::CurrencyType.all( @client )
+                currency_types.should be_a_instance_of( Array )
+                # currency_types.should have(9).items
+                currency_types[0].should respond_to(:title).with(0).arguments
+                currency_types[0].should respond_to(:description).with(0).arguments
+            end
+        end
+    end
+end

data/spec/big_door/end_user_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+module BigDoor 
+    describe EndUser do
+        before(:each) do
+            @client = BigDoor::Client.new( TEST_APP_SECRET, TEST_APP_KEY )
+        end
+        context "EndUser class" do
+            it "Should respond to :all" do 
+                BigDoor::EndUser.should respond_to(:all).with(1).arguments
+            end
+            it "Should load Array of end_users at the beginning" do
+                currency_types = BigDoor::EndUser.all( @client )
+                currency_types.should be_a_instance_of( Array )
+            end
+        end
+        context "fresh EndUser object" do 
+            subject { BigDoor::EndUser.new  }
+            it { should be }
+            it { should be_a_instance_of( BigDoor::EndUser )}
+        end
+    end
+end

data/spec/big_door/good_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+module BigDoor 
+    describe Good do
+        before(:each) do
+            @client = BigDoor::Client.new( TEST_APP_SECRET, TEST_APP_KEY )
+        end
+        context "fresh Good object" do 
+            subject { BigDoor::Good.new  }
+            it { should be }
+            it { should be_a_instance_of( BigDoor::Good )}
+        end
+    end
+end

data/spec/big_door/leaderboard_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+module BigDoor 
+    describe Leaderboard do
+        before(:each) do
+            @client = BigDoor::Client.new( TEST_APP_SECRET, TEST_APP_KEY )
+        end
+        context "fresh Leaderboard object" do 
+            subject { BigDoor::Leaderboard.new  }
+            it { should be }
+            it { should be_a_instance_of( BigDoor::Leaderboard )}
+            it { should respond_to(:execute).with(2).arguments}
+        end
+    end
+end

data/spec/big_door/level_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+module BigDoor 
+    describe Level do
+        before(:each) do
+            @client = BigDoor::Client.new( TEST_APP_SECRET, TEST_APP_KEY )
+        end
+        context "fresh Level object" do 
+            subject { BigDoor::Level.new  }
+            it { should be }
+            it { should be_a_instance_of( BigDoor::Level )}
+        end
+        context "Level class" do
+            it "Should respond to :all" do 
+                BigDoor::Level.should respond_to(:all).with(2).arguments
+            end
+        end
+    end
+end

data/spec/big_door/named_award_collection_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+module BigDoor 
+    describe NamedAwardCollection do
+        before(:each) do
+            @client = BigDoor::Client.new( TEST_APP_SECRET, TEST_APP_KEY )
+        end
+        context "NamedAwardCollection class" do
+            it "Should respond to :all" do 
+                BigDoor::NamedAwardCollection.should respond_to(:all).with(1).arguments
+            end
+            it "Should load Array of named award collections at the beginning" do
+                currency_types = BigDoor::NamedAwardCollection.all( @client )
+                currency_types.should be_a_instance_of( Array )
+            end
+        end
+        context "fresh NamedAwardCollection object" do 
+            subject { BigDoor::NamedAwardCollection.new  }
+            it { should be }
+            it { should be_a_instance_of( BigDoor::NamedAwardCollection )}
+        end
+    end
+end

data/spec/big_door/named_award_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+module BigDoor 
+    describe NamedAward do
+        before(:each) do
+            @client = BigDoor::Client.new( TEST_APP_SECRET, TEST_APP_KEY )
+        end
+        context "NamedAward class" do
+            it "Should respond to :all" do 
+                BigDoor::NamedAward.should respond_to(:all).with(1).arguments
+            end
+            it "Should load Array of named awards at the beginning" do
+                currency_types = BigDoor::NamedAward.all( @client )
+                currency_types.should be_a_instance_of( Array )
+            end
+        end
+        context "fresh NamedAward object" do 
+            subject { BigDoor::NamedAward.new  }
+            it { should be }
+            it { should be_a_instance_of( BigDoor::NamedAward )}
+        end
+    end
+end

data/spec/big_door/named_good_collection_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+module BigDoor 
+    describe NamedGoodCollection do
+        before(:each) do
+            @client = BigDoor::Client.new( TEST_APP_SECRET, TEST_APP_KEY )
+        end
+        context "NamedGoodCollection class" do
+            it "Should respond to :all" do 
+                BigDoor::NamedGoodCollection.should respond_to(:all).with(1).arguments
+            end
+            it "Should load Array of named good collections at the beginning" do
+                currency_types = BigDoor::NamedGoodCollection.all( @client )
+                currency_types.should be_a_instance_of( Array )
+            end
+        end
+        context "fresh NamedGoodCollection object" do 
+            subject { BigDoor::NamedGoodCollection.new  }
+            it { should be }
+            it { should be_a_instance_of( BigDoor::NamedGoodCollection )}
+        end
+    end
+end

data/spec/big_door/named_good_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+module BigDoor 
+    describe NamedGood do
+        before(:each) do
+            @client = BigDoor::Client.new( TEST_APP_SECRET, TEST_APP_KEY )
+        end
+        context "NamedGood class" do
+            it "Should respond to :all" do 
+                BigDoor::NamedGood.should respond_to(:all).with(1).arguments
+            end
+            it "Should load Array of named goods at the beginning" do
+                currency_types = BigDoor::NamedGood.all( @client )
+                currency_types.should be_a_instance_of( Array )
+            end
+        end
+        context "fresh NamedGood object" do 
+            subject { BigDoor::NamedGood.new  }
+            it { should be }
+            it { should be_a_instance_of( BigDoor::NamedGood )}
+        end
+    end
+end

data/spec/big_door/named_level_collection_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+module BigDoor 
+    describe NamedLevelCollection do
+        before(:each) do
+            @client = BigDoor::Client.new( TEST_APP_SECRET, TEST_APP_KEY )
+        end
+        context "NamedLevelCollection class" do
+            it "Should respond to :all" do 
+                BigDoor::NamedLevelCollection.should respond_to(:all).with(1).arguments
+            end
+            it "Should load Array of named level collections at the beginning" do
+                currency_types = BigDoor::NamedLevelCollection.all( @client )
+                currency_types.should be_a_instance_of( Array )
+            end
+        end
+        context "fresh NamedLevelCollection object" do 
+            subject { BigDoor::NamedLevelCollection.new  }
+            it { should be }
+            it { should be_a_instance_of( BigDoor::NamedLevelCollection )}
+        end
+    end
+end

data/spec/big_door/named_level_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+module BigDoor 
+    describe NamedLevel do
+        before(:each) do
+            @client = BigDoor::Client.new( TEST_APP_SECRET, TEST_APP_KEY )
+        end
+        context "NamedLevel class" do
+            it "Should respond to :all" do 
+                BigDoor::NamedLevel.should respond_to(:all).with(1).arguments
+            end
+            it "Should load Array of named levels at the beginning" do
+                currency_types = BigDoor::NamedLevel.all( @client )
+                currency_types.should be_a_instance_of( Array )
+                # currency_types.should be_empty
+            end
+        end
+        context "fresh NamedLevel object" do 
+            subject { BigDoor::NamedLevel.new  }
+            it { should be }
+            it { should be_a_instance_of( BigDoor::NamedLevel )}
+        end
+    end
+end

data/spec/big_door/named_transaction_group_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+module BigDoor 
+    describe NamedTransactionGroup do
+        before(:each) do
+            @client = BigDoor::Client.new( TEST_APP_SECRET, TEST_APP_KEY )
+        end
+        context "NamedTransactionGroup class" do
+            it "Should respond to :all" do 
+                BigDoor::NamedTransactionGroup.should respond_to(:all).with(1).arguments
+            end
+            it "Should load array of named transaction groups at the beginning" do
+                currency_types = BigDoor::NamedTransactionGroup.all( @client )
+                currency_types.should be_a_instance_of( Array )
+            end
+            subject { BigDoor::NamedTransactionGroup.new( {}  )  }
+            it { should be }
+            it { should be_instance_of BigDoor::NamedTransactionGroup}
+            it { should respond_to(:save).with(1).arguments}
+            it { should respond_to(:load).with(1).arguments}
+            it { should respond_to(:load).with(2).arguments}
+            it { should respond_to(:delete).with(1).arguments}
+            it { should respond_to(:delete).with(2).arguments}
+            it { should respond_to(:execute).with(3).arguments}
+            it { should respond_to(:associate_with).with(2).arguments}
+            it { should respond_to(:associate_with).with(3).arguments}
+        end
+    end
+end

data/spec/big_door/named_transaction_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+module BigDoor 
+    describe NamedTransaction do
+        before(:each) do
+            @client = BigDoor::Client.new( TEST_APP_SECRET, TEST_APP_KEY )
+        end
+        context "NamedTransaction class" do
+            it "Should respond to :all" do 
+                BigDoor::NamedTransaction.should respond_to(:all).with(1).arguments
+            end
+            it "Should load Array of named transactions at the beginning" do
+                currency_types = BigDoor::NamedTransaction.all( @client )
+                currency_types.should be_a_instance_of( Array )
+            end
+        end
+        context "fresh NamedTransaction object" do 
+            subject { BigDoor::NamedTransaction.new  }
+            it { should be }
+            it { should be_a_instance_of( BigDoor::NamedTransaction )}
+        end
+    end
+end

data/spec/big_door/profile_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+module BigDoor 
+    describe Profile do
+        before(:each) do
+            @client = BigDoor::Client.new( TEST_APP_SECRET, TEST_APP_KEY )
+        end
+        context "fresh Profile object" do 
+            subject { BigDoor::Profile.new  }
+            it { should be }
+            it { should be_a_instance_of( BigDoor::Profile )}
+        end
+        context "Profile class" do
+            it "Should respond to :all" do 
+                BigDoor::Profile.should respond_to(:all).with(2).arguments
+            end
+        end
+    end
+end

data/spec/big_door/resource_end_user_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+module BigDoor 
+    describe ResourceEndUser do
+        before(:each) do
+            @client = BigDoor::Client.new( TEST_APP_SECRET, TEST_APP_KEY )
+        end
+        context "ResourceEndUser class" do
+            it "Should respond to :all" do 
+                BigDoor::ResourceEndUser.should respond_to(:all).with(2).arguments
+            end
+            subject { BigDoor::ResourceEndUser.new( {}  )  }
+            it { should be }
+            it { should be_instance_of BigDoor::ResourceEndUser}
+            it { should respond_to(:save).with(1).arguments}
+            it { should respond_to(:load).with(1).arguments}
+            it { should respond_to(:load).with(2).arguments}
+            it { should respond_to(:delete).with(1).arguments}
+            it { should respond_to(:delete).with(2).arguments}
+        end
+    end
+end

data/spec/big_door/resource_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+module BigDoor 
+    describe Resource do
+        before(:each) do
+            @client = BigDoor::Client.new( TEST_APP_SECRET, TEST_APP_KEY )
+        end
+        context "Resource class" do
+            it "Should respond to :all" do 
+                BigDoor::Resource.should respond_to(:all).with(1).arguments
+            end
+            subject { BigDoor::Resource.new( {}  )  }
+            it { should be }
+            it { should be_instance_of BigDoor::Resource}
+            it { should respond_to(:save).with(1).arguments}
+            it { should respond_to(:load).with(1).arguments}
+            it { should respond_to(:load).with(2).arguments}
+            it { should respond_to(:delete).with(1).arguments}
+            it { should respond_to(:delete).with(2).arguments}
+        end
+    end
+end

data/spec/big_door/resource_with_association_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+module BigDoor 
+    describe ResourceWithAssociation do
+        before(:each) do
+            @client = BigDoor::Client.new( TEST_APP_SECRET, TEST_APP_KEY )
+        end
+        context "ResourceWithAssociation class" do
+            it "Should respond to :all" do 
+                BigDoor::ResourceWithAssociation.should respond_to(:all).with(1).arguments
+            end
+            subject { BigDoor::ResourceWithAssociation.new( {}  )  }
+            it { should be }
+            it { should be_instance_of BigDoor::ResourceWithAssociation}
+            it { should respond_to(:associate_with).with(2).arguments}
+            it { should respond_to(:save).with(1).arguments}
+            it { should respond_to(:load).with(1).arguments}
+            it { should respond_to(:load).with(2).arguments}
+            it { should respond_to(:delete).with(1).arguments}
+            it { should respond_to(:delete).with(2).arguments}
+        end
+    end
+end