gliffy 0.0.6 → 0.0.7

data/spec/fixtures/error-401.xml

@@ -0,0 +1 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?><response success="false" xmlns="http://www.gliffy.com"><error http-status="401">Your account has reached its maximum number of diagrams</error></response>

data/spec/lib/gliffy/account_spec.rb

@@ -1,107 +1,107 @@
-require 'spec_helper'
-
-describe Gliffy::Account do
-  let(:account_id) { 101 }
-  let(:expiration) { 32154788584000 }
-  let(:api) do
-    api = double(Gliffy::API)
-    api.stub(
-      :get_folders
-    ).and_return(
-      Gliffy::API::Response.new(fixture("folder"))
-    )
-    api
-  end
-
-  let(:account) do
-    response = Gliffy::API::Response.new(
-      fixture(
-        "account",
-        :account_id => account_id,
-        :expiration => expiration
-        )
-      )
-    Gliffy::Account.load(api, response)
-  end
-
-  it "has an id" do
-    expect(account).to respond_to :id
-    expect(account.id).to eq account_id
-  end
-
-  it "has a name" do
-    expect(account).to respond_to :name
-    expect(account.name).to eq "BurnsODyne"
-  end
-
-  it "has max users count" do
-    expect(account).to respond_to :max_users
-    expect(account.max_users).to eq 10
-  end
-
-  it "has a type" do
-    expect(account).to respond_to :type
-    expect(account.type).to eq Gliffy::Account::TYPE_BUSINESS
-  end
-
-  it "has 'terms accepted' flag" do
-    expect(account).to respond_to :terms_accepted
-    expect(account.terms_accepted).to be_true
-  end
-
-  it "has an expiration date" do
-    expect(account).to respond_to :expiration_date
-    expect(account.expiration_date).to eq Time.at(expiration / 1000).to_datetime
-  end
-
-  it "provides direct access to documents" do
-    expect(account).to respond_to :document
-  end
-
-  it "delegates task of fetching the document to API" do
-    document_id = 1011
-    document_name = "NAME"
-
-    document_fixture = fixture(
-      "document",
-      :document_id => document_id,
-      :document_name => document_name
-    )
-
-    api.should_receive(
-      :get
-    ).with(
-      "/accounts/#{account_id}/documents/#{document_id}/meta-data.xml",
-      hash_including(
-        :action => 'get'
-      )
-    ).and_return(Gliffy::API::Response.new(document_fixture))
-
-    document = account.document(document_id)
-
-    expect(document.id).to eq document_id
-    expect(document.name).to eq document_name
-    expect(document.owner).to be account
-  end
-
-  it "has a root folder" do
-    expect(account).to respond_to :root
-    expect(account.root).to be_instance_of Gliffy::Folder
-  end
-
-  describe "root folder" do
-    subject(:root_folder) { account.root }
-
-    it "is named ROOT" do
-      expect(root_folder.name).to eq "ROOT" 
-    end
-
-    it "has ROOT path" do
-      expect(root_folder.path).to eq "ROOT"
-    end
-
-    it "refers to the original account as owner" do
-      expect(root_folder.owner).to be account
-    end
-  end
-end
+require 'spec_helper'
+
+describe Gliffy::Account do
+  let(:account_id) { 101 }
+  let(:expiration) { 32154788584000 }
+  let(:api) do
+    api = double(Gliffy::API)
+    api.stub(
+      :get_folders
+    ).and_return(
+      Gliffy::API::Response.new(fixture("folder"))
+    )
+    api
+  end
+
+  let(:account) do
+    response = Gliffy::API::Response.new(
+      fixture(
+        "account",
+        :account_id => account_id,
+        :expiration => expiration
+        )
+      )
+    Gliffy::Account.load(api, response)
+  end
+
+  it "has an id" do
+    expect(account).to respond_to :id
+    expect(account.id).to eq account_id
+  end
+
+  it "has a name" do
+    expect(account).to respond_to :name
+    expect(account.name).to eq "BurnsODyne"
+  end
+
+  it "has max users count" do
+    expect(account).to respond_to :max_users
+    expect(account.max_users).to eq 10
+  end
+
+  it "has a type" do
+    expect(account).to respond_to :type
+    expect(account.type).to eq Gliffy::Account::TYPE_BUSINESS
+  end
+
+  it "has 'terms accepted' flag" do
+    expect(account).to respond_to :terms_accepted
+    expect(account.terms_accepted).to be_true
+  end
+
+  it "has an expiration date" do
+    expect(account).to respond_to :expiration_date
+    expect(account.expiration_date).to eq Time.at(expiration / 1000).to_datetime
+  end
+
+  it "provides direct access to documents" do
+    expect(account).to respond_to :document
+  end
+
+  it "delegates task of fetching the document to API" do
+    document_id = 1011
+    document_name = "NAME"
+
+    document_fixture = fixture(
+      "document",
+      :document_id => document_id,
+      :document_name => document_name
+    )
+
+    api.should_receive(
+      :get
+    ).with(
+      "/accounts/#{account_id}/documents/#{document_id}/meta-data.xml",
+      hash_including(
+        :action => 'get'
+      )
+    ).and_return(Gliffy::API::Response.new(document_fixture))
+
+    document = account.document(document_id)
+
+    expect(document.id).to eq document_id
+    expect(document.name).to eq document_name
+    expect(document.owner).to be account
+  end
+
+  it "has a root folder" do
+    expect(account).to respond_to :root
+    expect(account.root).to be_instance_of Gliffy::Folder
+  end
+
+  describe "root folder" do
+    subject(:root_folder) { account.root }
+
+    it "is named ROOT" do
+      expect(root_folder.name).to eq "ROOT" 
+    end
+
+    it "has ROOT path" do
+      expect(root_folder.path).to eq "ROOT"
+    end
+
+    it "refers to the original account as owner" do
+      expect(root_folder.owner).to be account
+    end
+  end
+end

data/spec/lib/gliffy/api/error_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe Gliffy::API::Error do
+  let(:code) { 401 }
+  let(:text) { "ERROR" }
+  let(:error) { Gliffy::API::Error.new(code, text) }
+
+  it "is an exception" do
+    expect(error).to be_a_kind_of Exception
+  end
+
+  it "has an error code" do
+    expect(error).to respond_to :code
+  end
+
+  it "has an error text" do
+    expect(error).to respond_to :text
+  end
+
+  it "can be implicitly converted to string" do
+    expect(error).to respond_to :to_s
+  end
+
+  describe "string representation" do
+    subject(:message) { error.to_s }
+
+    it "should contain error code" do
+      expect(message).to match error.code.to_s
+    end
+
+    it "should contain error text" do
+      expect(message).to match error.text
+    end
+  end
+end

data/spec/lib/gliffy/api/facade_spec.rb

@@ -1,111 +1,240 @@
 require 'spec_helper'
 
 shared_examples_for "an API facade" do
-    context "when sending GET request" do
-        it "forwards request to the API backend with HTTP protocol" do
-            api.should_receive(
-                :get
-            ).with(
-                match(url_matcher),
-                hash_including(params)
-            ).and_return(response)
-
-            expect(facade.get("/test", params)).to be response
-        end 
-    end
-
-    context "when sending POST request" do
-        it "forwards request to the API backend with HTTP protocol" do
-            api.should_receive(
-                :post
-            ).with(
-                match(url_matcher),
-                hash_including(params)
-            ).and_return(response)
-
-            expect(facade.post("/test", params)).to be response
-        end 
-    end
-
-    context "when GETting raw resource contents" do
-        it "forwards request to the API backend with HTTP protocol" do
-            api.should_receive(
-                :raw
-            ).with(
-                match(url_matcher),
-                hash_including(params)
-            ).and_return(response)
-
-            expect(facade.raw("/test", params)).to be response
-        end
-    end
-
-    context "when generating web link" do
-        it "forwards request to the API backend with HTTP protocol" do
-            api.should_receive(
-                :web
-            ).with(
-                match(url_matcher),
-                hash_including(params)
-            ).and_return(response)
-
-            expect(facade.web("/test", params)).to be response
-        end
-    end
-
-    context "when loading a list of folders" do
-        it "wraps own 'get' method" do
-            account_id = 99
-
-            facade.should_receive(
-                :get
-            ).with(
-                "/accounts/#{account_id}/folders.xml",
-                { :action => "get"}
-            ).and_return(response)
-
-            expect(facade.get_folders(account_id)).to be response
-        end
+  context "when sending GET request" do
+    it "forwards request to the API backend with HTTP protocol" do
+      api.should_receive(
+                         :get
+                         ).with(
+                                match(url_matcher),
+                                hash_including(params)
+                                ).and_return(response)
+
+      expect(facade.get("/test", params)).to be response
     end
+  end
+
+  context "when sending POST request" do
+    it "forwards request to the API backend with HTTP protocol" do
+      api.should_receive(
+                         :post
+                         ).with(
+                                match(url_matcher),
+                                hash_including(params)
+                                ).and_return(response)
+
+      expect(facade.post("/test", params)).to be response
+    end
+  end
+
+  context "when GETting raw resource contents" do
+    it "forwards request to the API backend with HTTP protocol" do
+      api.should_receive(
+                         :raw
+                         ).with(
+                                match(url_matcher),
+                                hash_including(params)
+                                ).and_return(response)
+
+      expect(facade.raw("/test", params)).to be response
+    end
+  end
+
+  context "when generating web link" do
+    it "forwards request to the API backend with HTTP protocol" do
+      api.should_receive(
+                         :web
+                         ).with(
+                                match(url_matcher),
+                                hash_including(params)
+                                ).and_return(response)
+
+      expect(facade.web("/test", params)).to be response
+    end
+  end
+
+  context "when loading a list of folders" do
+    it "wraps own 'get' method" do
+      account_id = 99
+
+      facade.should_receive(
+                            :get
+                            ).with(
+                                   "/accounts/#{account_id}/folders.xml",
+                                   { :action => "get"}
+                                   ).and_return(response)
+
+      expect(facade.get_folders(account_id)).to be response
+    end
+  end
+
+  context "when updating document metadata" do
+    let(:document_id) { 221 }
+    let(:document_name) { "NEW DOCUMENT" }
+    let(:public_flag) { true }
+    let(:public_text) { "true" }
+
+    it "sends POST request" do
+      facade
+        .should_receive(:post)
+        .with("/accounts/#{account_id}/documents/#{document_id}/meta-data.xml",
+              hash_including(:action => "update",
+                             :documentName => document_name,
+                             :public => public_text))
+
+      facade.update_document_metadata(document_id, document_name, public_flag)
+    end
+
+    it "doesn't send name if no name is passed to the method" do
+      facade
+        .should_receive(:post)
+        .with(anything(),
+              hash_not_including(:documentName))
+
+      facade.update_document_metadata(document_id, nil, public_flag)
+    end
+
+    it "doesn't send public flag if it is not passed to the method" do
+      facade
+        .should_receive(:post)
+        .with(anything(),
+              hash_not_including(:public))
+
+      facade.update_document_metadata(document_id, document_name, nil)
+    end
+  end
+
+  it "allows user to delete a document" do
+    expect(facade).to respond_to :delete_document
+  end
+
+  context "when deleting a document" do
+    let(:document_id) { 221 }
+
+    it "sends POST request" do
+      facade
+        .should_receive(:post)
+        .with("/accounts/#{account_id}/documents/#{document_id}.xml",
+              hash_including(:action => "delete"))
+
+      facade.delete_document(document_id)
+    end
+  end
+
+  it "allows user to create a document" do
+    expect(facade).to respond_to :create_document
+  end
+
+  context "when creating a document" do
+    let(:document_name) { "NAME" }
+    let(:document_type) { Gliffy::Document::TYPE_DIAGRAM }
+    let(:original_id) { 45 }
+    let(:path) { "ROOT/FOLDER" }
+
+    it "sends POST request" do
+      facade.should_receive(:post)
+        .with("/accounts/#{account_id}/documents.xml",
+              hash_including(:action => "create",
+                             :documentName => document_name,
+                             :documentType => document_type,
+                             :templateDiagramId => original_id,
+                             :folderPath => path))
+
+      facade.create_document(document_name, document_type, original_id, path)
+    end
+
+    context "when template id is not provided" do
+      it "doesn't send template id" do
+        facade.should_receive(:post)
+          .with(anything(),
+                hash_not_including(:templateDiagramId))
+
+        facade.create_document(document_name, document_type, nil, path)
+      end
+    end
+
+    context "when path is not provided" do
+      it "doesn't send path" do
+        facade.should_receive(:post)
+          .with(anything(),
+                hash_not_including(:folderPath))
+
+        facade.create_document(document_name, document_type, original_id, nil)
+      end
+    end
+  end
+
+  context "when POST request returns an error" do
+    let(:response) { Gliffy::API::Response.new(fixture("error-401")) }
+
+    before :each do
+      api.stub(
+        :post
+      ).and_return(
+        response
+      )
+    end
+
+    it "throws an exception" do
+      expect { facade.post("/random_url", {}) }.to raise_error(Gliffy::API::Error)
+    end
+  end
+
+  context "when GET request returns an error" do
+    let(:response) { Gliffy::API::Response.new(fixture("error-401")) }
+
+    before :each do
+      api.stub(
+        :get
+      ).and_return(
+        response
+      )
+    end
+
+    it "throws an exception" do
+      expect { facade.get("/random_url", {}) }.to raise_error(Gliffy::API::Error)
+    end
+  end
 end
 
 describe Gliffy::API::Facade do
-    let(:api) { double(Gliffy::API) }
-    let(:response) { double(Gliffy::API::Response) }
-    let(:params) {               
-        {
-            :test1 => "value1",
-            :test2 => "value2"
-        }   
+  let(:account_id) { 99 }
+  let(:api) { double(Gliffy::API, { :account_id => account_id }) }
+  let(:response) { double(Gliffy::API::Response, :error? => false) }
+  let(:params) {
+    {
+      :test1 => "value1",
+      :test2 => "value2"
     }
+  }
 
-    describe "plain facade" do
-        let(:facade) { Gliffy::API::Facade.http(api) }
+  describe "plain facade" do
+    let(:facade) { Gliffy::API::Facade.http(api) }
 
-        it_should_behave_like "an API facade" do
-            let(:url_matcher) { %{http://.+/test} }
-        end
+    it_should_behave_like "an API facade" do
+      let(:url_matcher) { %{http://.+/test} }
     end
+  end
 
-    describe "secure facade" do
-        let(:facade) { Gliffy::API::Facade.https(api) }
+  describe "secure facade" do
+    let(:facade) { Gliffy::API::Facade.https(api) }
 
-        it_should_behave_like "an API facade" do
-            let(:url_matcher) { %{https://.+/test} }
-        end
+    it_should_behave_like "an API facade" do
+      let(:url_matcher) { %{https://.+/test} }
     end
+  end
 
-    describe "static methods" do
-        subject { Gliffy::API::Facade }
+  describe "static methods" do
+    subject { Gliffy::API::Facade }
 
-        it "provide access to API via basic HTTP protocol" do
-            expect(subject).to respond_to :http
-            expect(subject.http(api)).to be_instance_of Gliffy::API::Facade
-        end
+    it "provide access to API via basic HTTP protocol" do
+      expect(subject).to respond_to :http
+      expect(subject.http(api)).to be_instance_of Gliffy::API::Facade
+    end
 
-        it "provide access to API via secure HTTPS protocol" do
-            expect(subject).to respond_to :https
-            expect(subject.https(api)).to be_instance_of Gliffy::API::Facade
-        end
+    it "provide access to API via secure HTTPS protocol" do
+      expect(subject).to respond_to :https
+      expect(subject.https(api)).to be_instance_of Gliffy::API::Facade
     end
-end
+  end
+end