jirafe 0.1.0

data/spec/jirafe/jirafe_spec.rb

@@ -0,0 +1,23 @@
+require "spec_helper"
+
+describe Jirafe do
+  describe ".configure" do
+    before { Jirafe::Configuration.instance.reset! }
+    after { Jirafe::Configuration.instance.reset! }
+
+    it "should set all values on the configuration instance" do
+      Jirafe.configure do |config|
+        config.url = "http://myurl"
+        config.token = "sometoken"
+        config.test = false
+        config.logger = Logger.new('/dev/null')
+      end
+      instance = Jirafe::Configuration.instance
+      instance.url.should == "http://myurl"
+      instance.token = "sometoken"
+      instance.test.should be_false
+      instance.logger.should be_instance_of(Logger)
+    end
+  end
+end
+

data/spec/jirafe/resource/application_spec.rb

@@ -0,0 +1,220 @@
+require "spec_helper"
+
+describe Jirafe::Resource::Application do
+  let(:resource_class) { Jirafe::Resource::Application }
+  let(:application_id) { 1 }
+  let(:application_name) { "my application" }
+
+  describe ".retrieve" do
+    subject { make_request(cassette) { resource_class.retrieve(application_id) } }
+
+    context "when the token is the master token" do
+      before { use_master_token }
+      let(:cassette) { "application_get_with_master_token" }
+      its(:class) { should == Jirafe::Resource::Application }
+      its(:identifier) { should == application_id }
+      its(:name) { should == application_name }
+
+      context "but the application id is invalid" do
+        let(:application_id) { - 1}
+
+        it "raises an error" do
+          expect { subject }.to raise_error(Jirafe::Error::ResourceNotFound)
+        end
+      end
+    end
+
+    context "when the token is the reporting token" do
+      before { use_reporting_token }
+      let(:cassette) { "application_get_with_reporting_token" }
+
+      its(:class) { should == Jirafe::Resource::Application }
+      its(:identifier) { should == application_id }
+      its(:name) { should == application_name }
+    end
+
+    context "when the token is the cloud token" do
+      before { use_cloud_token }
+      let(:cassette) { "application_get_with_cloud_token" }
+
+      it "raises an error" do
+        expect { subject }.to raise_error(Jirafe::Error::Forbidden)
+      end
+    end
+
+    context "when the token is an invalid token" do
+      before { use_invalid_token }
+      let(:cassette) { "application_get_with_invalid_token" }
+
+      it "raises an error" do
+        expect { subject }.to raise_error(Jirafe::Error::Unauthorized)
+      end
+    end
+  end
+
+  describe ".create" do
+    subject { make_request(cassette) { resource.create } }
+
+    context "when the token is the master token" do
+      before { use_master_token }
+
+      context "and the resource is new" do
+        let(:cassette) { "application_post_with_master_token" }
+        let(:resource) { Jirafe::Resource::Application.new(:name => "my new app") }
+
+        its(:class) { should == Jirafe::Resource::Application }
+        its(:identifier) { should be_nonzero }
+        its(:name) { should == "my new app" }
+        its(:app_id) { should_not be_nil }
+        its(:token) { should_not be_nil }
+
+        context "with a duplicate name" do
+          before { resource.name = application_name }
+          let(:cassette) { "application_post_with_master_token_dupe_name" }
+
+          its(:name) { should == application_name }
+        end
+
+        context "with a blank name" do
+          before { resource.name = "" }
+          let(:cassette) { "application_post_with_master_token_blank_name" }
+
+          it "raises an error" do
+            expect { subject }.to raise_error(Jirafe::Error::BadRequest)
+          end
+        end
+
+        context "with no name" do
+          before { resource.name = nil }
+          let(:cassette) { "application_post_with_master_token_no_name" }
+
+          it "raises an error" do
+            expect { subject }.to raise_error(Jirafe::Error::BadRequest)
+          end
+        end
+      end
+    end
+
+    context "when the token is the report token" do
+      before { use_reporting_token }
+
+      context "and the resource is new" do
+        let(:cassette) { "application_post_with_reporting_token" }
+        let(:resource) { Jirafe::Resource::Application.new(:name => "my new app") }
+
+        its(:identifier) { should be_nonzero }
+        its(:name) { should == "my new app" }
+      end
+    end
+
+    context "when the token is the cloud token" do
+      before { use_reporting_token }
+
+      context "and the resource is new" do
+        let(:cassette) { "application_post_with_cloud_token" }
+        let(:resource) { Jirafe::Resource::Application.new(:name => "my new app") }
+
+        its(:identifier) { should be_nonzero }
+        its(:name) { should == "my new app" }
+      end
+    end
+
+    context "when the token is an invalid token" do
+      before { use_invalid_token }
+
+      context "and the resource is new" do
+        let(:cassette) { "application_post_with_invalid_token" }
+        let(:resource) { Jirafe::Resource::Application.new(:name => "my new app") }
+
+        it "raises an error" do
+          expect { subject }.to raise_error(Jirafe::Error::Unauthorized)
+        end
+      end
+
+      context "and the resource already exists" do
+        let(:cassette) { "application_put_with_invalid_token" }
+        let(:resource) { Jirafe::Resource::Application.new(:identifier => application_id, :name => "my new app") }
+
+        it "raises an error" do
+          expect { subject }.to raise_error(Jirafe::Error::Unauthorized)
+        end
+      end
+    end
+  end
+
+  describe ".update" do
+    subject { make_request(cassette) { resource.update } }
+
+    context "when the token is the master token" do
+      before { use_master_token }
+
+      context "and the resource already exists" do
+        let(:cassette) { "application_put_with_master_token" }
+        let(:resource) { Jirafe::Resource::Application.new(:identifier => application_id, :name => "my new app") }
+
+        it "raises an error" do
+          expect { subject }.to raise_error(Jirafe::Error::Forbidden)
+        end
+      end
+    end
+
+    context "when the token is the report token" do
+      before { use_reporting_token }
+
+      context "and the resource already exists" do
+        let(:cassette) { "application_put_with_reporting_token" }
+        let(:resource) { Jirafe::Resource::Application.new(:identifier => application_id, :name => "my new app") }
+
+        it "raises an error" do
+          expect { subject }.to raise_error(Jirafe::Error::Forbidden)
+        end
+      end
+    end
+
+    context "when the token is the cloud token" do
+      before { use_reporting_token }
+
+      context "and the resource already exists" do
+        let(:cassette) { "application_put_with_cloud_token" }
+        let(:resource) { Jirafe::Resource::Application.new(:identifier => application_id, :name => "my new app") }
+
+        it "raises an error" do
+          expect { subject }.to raise_error(Jirafe::Error::Forbidden)
+        end
+      end
+    end
+
+    context "when the token is an invalid token" do
+      before { use_invalid_token }
+
+      context "and the resource is new" do
+        let(:cassette) { "application_put_with_invalid_token" }
+        let(:resource) { Jirafe::Resource::Application.new(:identifier => application_id, :name => "my new app") }
+
+        it "raises an error" do
+          expect { subject }.to raise_error(Jirafe::Error::Unauthorized)
+        end
+      end
+
+      context "and the resource already exists" do
+        let(:cassette) { "application_put_with_invalid_token" }
+        let(:resource) { Jirafe::Resource::Application.new(:identifier => application_id, :name => "my new app") }
+
+        it "raises an error" do
+          expect { subject }.to raise_error(Jirafe::Error::Unauthorized)
+        end
+      end
+    end
+  end
+
+  describe "#sites" do
+    subject { make_request(cassette) { resource.sites } }
+    let(:resource) { Jirafe::Resource::Application.new(:identifier => application_id, :name => "my new app") }
+
+    let(:cassette) { "application_sites_get_with_master_token" }
+
+    its(:class) { should == Array }
+    its(:size) { should == 1 }
+  end
+
+end

data/spec/jirafe/resource/jirafe_resource_spec.rb

@@ -0,0 +1,188 @@
+require "spec_helper"
+
+describe Jirafe::Resource::JirafeResource do
+  let(:resource_class) { Jirafe::Resource::JirafeResource }
+  before do
+    class TestResourceClass < Jirafe::Resource::JirafeResource
+    end
+    class ParentResourceClass < Jirafe::Resource::JirafeResource
+      path "parent"
+      attributes({:identifier => [:identifier]})
+    end
+    class ChildResourceClass < Jirafe::Resource::JirafeResource
+      path "child"
+      parent ParentResourceClass
+      attributes({:identifier => [:identifier]})
+    end
+    class GrandChildResourceClass < Jirafe::Resource::JirafeResource
+      path "grandchild"
+      parent ChildResourceClass
+      attributes({:identifier => [:identifier]})
+    end
+  end
+
+  describe ".path" do
+    subject { resource_class.path(path) }
+    after { resource_class.instance_variable_set("@path", nil) }
+
+    context "when given a path" do
+      let(:path) { "mypath" }
+
+      context "and the base resource class" do
+        it { should == Jirafe.config.url }
+      end
+
+      context "and given a subclass" do
+        let(:resource_class) { TestResourceClass }
+
+        it { should == "mypath" }
+      end
+    end
+
+    context "given no path" do
+      let(:path) { nil }
+      context "and it is not already set" do
+        context "and the base resource class" do
+          it { should == Jirafe.config.url }
+        end
+
+        context "and given a subclass" do
+          let(:resource_class) { TestResourceClass }
+
+          it "raises an error" do
+            expect { subject }.to raise_error(Jirafe::Error::MissingResourcePath)
+          end
+        end
+      end
+
+      context "and it is already set" do
+        context "and the base resource class" do
+          it { should == Jirafe.config.url }
+        end
+
+        context "and given a subclass" do
+          let(:resource_class) { TestResourceClass }
+
+          it "returns the path" do
+            resource_class.path("newpath")
+            resource_class.path.should == "newpath"
+          end
+        end
+      end
+    end
+  end
+
+  describe ".parent" do
+    subject { resource_class.parent(parent) }
+    after { resource_class.instance_variable_set("@parent", nil) }
+
+    context "when given a parent" do
+      let(:parent) { "parent" }
+
+      context "and given a subclass" do
+        let(:resource_class) { TestResourceClass }
+
+        it { should == "parent" }
+      end
+    end
+
+    context "given no parent" do
+      let(:parent) { nil }
+      context "and given a subclass" do
+        let(:resource_class) { TestResourceClass }
+        it { should == resource_class.superclass }
+      end
+    end
+  end
+
+  describe "#parent" do
+    subject { resource_class.new.parent }
+
+    context "given the base resource class" do
+      it { should be_nil }
+    end
+  end
+
+  describe "#resource_url" do
+    subject { resource.resource_url }
+    let(:resource) { resource_class.new }
+    let(:base_url) { Jirafe.config.url }
+
+    context "given the base resource class" do
+      it { should == base_url }
+    end
+
+    context "given a subclass" do
+      let(:resource_class) { ParentResourceClass }
+
+      context "with no identifier" do
+        it { should == "#{base_url}/parent"}
+      end
+
+      context "with an identifier" do
+        let(:resource) { resource_class.new(:identifier => 1) }
+
+        it { should == "#{base_url}/parent/1"}
+      end
+    end
+
+    context "given a child subclass" do
+      let(:resource_class) { ChildResourceClass }
+
+      context "with a parent identifier" do
+        let(:parent_resource) { ParentResourceClass.new(:identifier => 1) }
+        let(:resource) { resource_class.new(:parent => parent_resource) }
+        it { should == "#{base_url}/parent/1/child"}
+
+        context "with an identifier" do
+          let(:resource) { resource_class.new(:parent => parent_resource, :identifier => 2) }
+          it { should == "#{base_url}/parent/1/child/2"}
+
+          context "and deeply nested" do
+            let(:resource) do
+              GrandChildResourceClass.new(
+                :parent => ChildResourceClass.new(
+                  :parent => ParentResourceClass.new(
+                    :identifier => 1),
+                    :identifier => 2),
+                    :identifier => 3)
+            end
+
+            it { should == "#{base_url}/parent/1/child/2/grandchild/3"}
+          end
+        end
+      end
+    end
+  end
+
+
+  describe ".get" do
+    subject {  make_request(cassette) { resource_class.get(url).parsed_response } }
+
+    context "given a url" do
+      let(:url) { "/status" }
+      let(:cassette) { "jirafe_resource_get_status_url" }
+
+      it { should == {"status" => "ok"} }
+    end
+  end
+
+  describe ".retrieve" do
+    subject {  make_request(cassette) { resource_class.retrieve } }
+    let(:cassette) { "jirafe_resource_get_status_url" }
+    let(:resource_class) { Jirafe::Resource::Status }
+
+    its(:class) { should == resource_class }
+    its(:status) { should == "ok" }
+
+    context "with an option" do
+      subject {  make_request(cassette) { resource_class.retrieve(nil, {:query_param => true}) } }
+      let(:cassette) { "jirafe_resource_get_status_url_with_query_param" }
+      let(:resource_class) { Jirafe::Resource::Status }
+
+      its(:class) { should == resource_class }
+      its(:status) { should == "ok" }
+    end
+  end
+end
+

data/spec/jirafe/resource/site_spec.rb

@@ -0,0 +1,61 @@
+require "spec_helper"
+
+describe Jirafe::Resource::Site do
+  let(:resource_class) { Jirafe::Resource::Site }
+  let(:application_id) { 1 }
+  let(:site_id) { 1 }
+  let(:site_description) { "Test Site" }
+  let(:site_url) { "http://jirafe.com" }
+  let(:site_timezone) { "Europe/Paris" }
+  let(:site_currency) { "EUR" }
+
+  describe ".retrieve" do
+    subject { make_request(cassette) { resource_class.retrieve(site_id, application_id) } }
+
+    let(:cassette) { "site_get_with_master_token" }
+
+    its(:class) { should == resource_class }
+    its(:identifier) { should == site_id }
+    its(:description) { should == site_description }
+    its(:url) { should == site_url }
+    its(:timezone) { should == site_timezone }
+    its(:currency) { should == site_currency }
+  end
+
+  describe ".list" do
+    subject { make_request(cassette) { resource_class.list(application_id) } }
+    let(:cassette) { "site_get_with_master_token" }
+
+    its(:class) { should == Array }
+    its(:size) { should == 1 }
+  end
+
+  describe ".create" do
+    subject { make_request(cassette) { resource.create } }
+    let(:app) { Jirafe::Resource::Application.new(:name => "my new app") }
+
+    context "when the token is the app token" do
+      before do
+        use_master_token
+        make_request "application_post_with_master_token" do
+          app.create
+        end
+        resource.app_id = app.identifier
+        resource.parent = app
+
+        use_app_token(app)
+      end
+
+      context "and the resource is new" do
+        let(:cassette) { "site_post_with_app_token" }
+        let(:resource) { Jirafe::Resource::Site.new(:description => "my new site", :url => "http://example.com/") }
+
+        its(:class) { should == Jirafe::Resource::Site }
+        its(:identifier) { should be_nonzero }
+        its(:description) { should == "my new site" }
+        its(:url) { should == "http://example.com/" }
+      end
+    end
+  end
+
+end