gliffy 0.0.6

data/lib/gliffy/oauth/helper.rb

@@ -0,0 +1,10 @@
+# Gliffy OAuth implementation is screwed  - longer nonce values causes
+# it to complain about the  timestamp value; we're limiting the length
+# to 25 characters here
+module OAuth
+  module Helper
+    def generate_key(size=25)
+      Base64.encode64(OpenSSL::Random.random_bytes(size)).gsub(/\W/, '')
+    end
+  end
+end

data/spec/fixtures/account.xml

@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<response xmlns="http://www.gliffy.com" success="true">
+    <accounts>
+        <account max-users="10"
+                 account-type="Business"
+                 terms="true" 
+                 id="%{account_id}">
+            <name>BurnsODyne</name>
+            <expiration-date>%{expiration}</expiration-date>
+            <users>
+                <user id="209">
+                    <username>barney</username>
+                    <email>barney@BurnsODyne.apiuser.gliffy.com</email>
+                </user>
+                <user id="205">
+                     <username>bart</username>
+                     <email>bart@BurnsODyne.apiuser.gliffy.com</email>
+                </user>
+                <user id="210">
+                     <username>discostu</username>
+                     <email>discostu@BurnsODyne.apiuser.gliffy.com</email>
+                </user>
+            </users>
+        </account>
+    </accounts>
+</response>

data/spec/fixtures/document.xml

@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<response xmlns="http://www.gliffy.com" success="true">
+    <documents>
+        <document is-public="true" num-versions="5" id="%{document_id}">
+            <name>%{document_name}</name>
+            <mod-date>1215538283000</mod-date>
+            <create-date>1215538284000</create-date>
+            <published-date>1215538285000</published-date>
+            <owner id="203">
+                <username>smithers</username>
+                <email>smithers@BurnsODyne.apiuser.gliffy.com</email>
+            </owner>
+        </document>
+    </documents>
+</response>

data/spec/fixtures/documents-empty.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<response xmlns="http://www.gliffy.com" success="true">
+    <documents></documents>
+</response>

data/spec/fixtures/documents.xml

@@ -0,0 +1,35 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<response xmlns="http://www.gliffy.com" success="true">
+    <documents>
+        <document num-versions="4" id="1000000">
+            <name>Проверка</name>
+            <mod-date>1215538283000</mod-date>
+            <create-date>1215538283000</create-date>
+            <published-date>1215538283000</published-date>
+            <owner id="202">
+                <username>monty</username>
+                <email>monty@BurnsODyne.apiuser.gliffy.com</email>
+            </owner>
+        </document>
+        <document is-public="true" num-versions="5" id="1000002">
+            <name>SNPP Domain Model</name>
+            <mod-date>1215538283000</mod-date>
+            <create-date>1215538283000</create-date>
+            <published-date>1215538283000</published-date>
+            <owner id="203">
+                <username>smithers</username>
+                <email>smithers@BurnsODyne.apiuser.gliffy.com</email>
+            </owner>
+        </document>
+        <document num-versions="2" id="1000001">
+            <name>World Domination Flow</name>
+            <mod-date>1215538283000</mod-date>
+            <create-date>1215538283000</create-date>
+            <published-date>1215538283000</published-date>
+            <owner id="202">
+                <username>monty</username>
+                <email>monty@BurnsODyne.apiuser.gliffy.com</email>
+            </owner>
+        </document>
+    </documents>
+</response>

data/spec/fixtures/folder.xml

@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<response xmlns="http://www.gliffy.com" success="true">
+    <folders>
+        <folder is-default="true">
+            <name>ROOT</name>
+            <path>ROOT</path>
+            <folder is-default="false">
+                <name>Burns Top Secret</name>
+                <path>ROOT/Burns Top Secret</path>
+            </folder>
+            <folder is-default="false">
+                <name>Casino</name>
+                <path>ROOT/Casino</path>
+            </folder>
+            <folder is-default="false">
+                <name>Drunks Only</name>
+                <path>ROOT/Drunks Only</path>
+            </folder>
+            <folder is-default="false">
+                <name>Simpsons Family</name>
+                <path>ROOT/Simpsons Family</path>
+                <folder is-default="false">
+                    <name>Bart Only</name>
+                    <path>ROOT/Simpsons Family/Bart Only</path>
+                </folder>
+                <folder is-default="false">
+                    <name>Maggie and Lisas Stuff</name>
+                    <path>ROOT/Simpsons Family/Maggie and Lisas Stuff</path>
+                </folder>
+            </folder>
+        </folder>
+    </folders>
+</response>

data/spec/fixtures/token.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<response xmlns="http://www.gliffy.com" success="true">
+    <oauth-token-credentials>
+        <oauth-token>140a1b58c248d13872499df769606766</oauth-token>
+        <oauth-token-secret>481830f5827e35b0644a32c1caac5245</oauth-token-secret>
+        <create-date>1236204382765</create-date>
+    </oauth-token-credentials>
+</response>

data/spec/lib/gliffy/account_spec.rb

@@ -0,0 +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

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

@@ -0,0 +1,111 @@
+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
+    end
+end
+
+describe Gliffy::API::Facade do
+    let(:api) { double(Gliffy::API) }
+    let(:response) { double(Gliffy::API::Response) }
+    let(:params) {               
+        {
+            :test1 => "value1",
+            :test2 => "value2"
+        }   
+    }
+
+    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
+    end
+
+    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
+    end
+
+    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 secure HTTPS protocol" do
+            expect(subject).to respond_to :https
+            expect(subject.https(api)).to be_instance_of Gliffy::API::Facade
+        end
+    end
+end

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

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe Gliffy::API::Response do
+    let(:xml) { fixture("documents") }
+    let(:response) { Gliffy::API::Response.new(xml) }
+
+    it "allows to search node by XPath expression" do
+        expect(response).to respond_to :node
+        expect(
+            response.node("//g:documents")
+        ).to be_instance_of Gliffy::API::Response
+    end
+
+    it "allows to search for a set of nodes by XPath expression" do
+        expect(response).to respond_to :nodes
+
+        result = response.nodes("//g:document")
+        expect(result).to be_instance_of Array
+        expect(result.length).to eq 3
+    end
+
+    it "allows to access text node content" do
+        node = response.node("//g:document[3]/g:name")
+        expect(node).to respond_to :content
+        expect(
+            node.content
+        ).to eq "World Domination Flow"
+    end
+
+    it "allows to get string node content by XPath expression" do
+        expect(response).to respond_to :string
+        expect(
+            response.string("//g:document[2]/g:name")
+        ).to eq "SNPP Domain Model"
+    end
+
+    it "allows to get integer node content by XPath expression" do
+        expect(response).to respond_to :integer
+        expect(
+            response.integer("//g:document[1]/g:owner/@id")
+        ).to eq 202
+    end
+
+    it "allows to get timestamps by XPath expression" do
+        expect(response).to respond_to :timestamp
+        expect(
+            response.timestamp("//g:document[1]/g:create-date")
+        ).to eq Time.at(1215538283000 / 1000).to_datetime
+    end
+
+    it "allows to check for a node existence by XPath" do
+        expect(response).to respond_to :exists
+        expect(response.exists("//g:document[1]/@is-public")).to be_false
+        expect(response.exists("//g:document[2]/@is-public")).to be_true
+    end
+end

data/spec/lib/gliffy/api_spec.rb

@@ -0,0 +1,206 @@
+require 'spec_helper'
+
+describe Gliffy::API do
+  let(:key) { "sample-key" }
+  let(:secret) { "sample-secret" }
+  let(:account_id) { 112233 }
+  let(:consumer) { double(OAuth::Consumer) }
+  let(:api) { Gliffy::API.new(account_id, key, secret) }
+
+  it "has an OAuth service consumer" do
+    expect(api).to respond_to :consumer
+    expect(api.consumer).to be_instance_of OAuth::Consumer
+  end
+
+  context "when being initialized" do
+    it "uses API key and shared secret to create a new OAuth consumer object" do
+      OAuth::Consumer.should_receive(
+        :new
+      ).with(
+        key,
+        secret,
+        hash_including(:site => Gliffy.web_root, :scheme => :query_string)
+      ).and_return(
+        consumer
+      )
+
+      api = Gliffy::API.new(account_id, key, secret)
+      expect(api.consumer).to be(consumer)
+    end
+  end
+
+  it "has a Gliffy API account id" do
+    expect(api).to respond_to :account_id
+    expect(api.account_id).to eq account_id
+  end
+
+  it "has a Giffy account" do
+    response = fixture(
+      "account",
+      :account_id => account_id,
+      :expiration => 1000
+    )
+    account = double(Gliffy::Account)
+
+    Gliffy::API::Facade.any_instance.stub(:get).and_return(response)
+    Gliffy::Account.should_receive(
+      :load
+    ).with(
+      instance_of(Gliffy::API::Facade),
+      response
+    ).and_return(account)
+
+    expect(api).to respond_to :account
+    expect(api.account).to be account
+  end
+
+  it "has an application name" do
+    expect(api).to respond_to :application_name
+  end
+
+  describe "application name" do
+    it "has a default value" do
+      expect(api.application_name).to eq Gliffy.default_application_name
+    end
+
+    it "can be overridden" do
+      expect(api).to respond_to :application_name=
+
+      test_name = "TEST APP NAME"
+      api.application_name = test_name
+      expect(api.application_name).to eq test_name
+    end
+  end
+
+  it "has a plain HTTP API facade" do
+    expect(api).to respond_to :plain
+    expect(api.plain).to be_instance_of Gliffy::API::Facade
+  end
+
+  it "has a secure HTTPS API facade" do
+    expect(api).to respond_to :secure
+    expect(api.secure).to be_instance_of Gliffy::API::Facade
+  end
+
+  it "handles GET requests" do
+    expect(api).to respond_to :get
+  end
+
+  it "handles raw GET requests" do
+    expect(api).to respond_to :raw
+  end
+
+  it "handles POST requests" do
+    expect(api).to respond_to :post
+  end
+
+  it "generates signed web links" do
+    expect(api).to respond_to :web
+  end
+
+  context "when doing a request" do
+    let(:url) { 'http://www.gliffy.com/test' }
+    let(:params) { { :param => 'value' } }
+    let(:xml) { fixture_xml("document", :document_id => 11, :document_name => "TEST" ) }
+    let(:raw) { double(Object, :body => xml) }
+
+    it "delegates to 'raw' call when doing GET" do
+      api.should_receive(
+        :raw
+      ).with(
+        url, params
+      ).and_return(xml)
+
+      result = api.get(url, params)
+
+      expect(result.exists('//g:documents')).to be_true
+    end
+
+    it "delegates raw GET requsts to OAuth token instance" do
+      OAuth::AccessToken.any_instance.should_receive(
+        :get
+      ).with(
+        'http://www.gliffy.com/test?param=value'
+      ).and_return(raw)
+
+      result = api.raw(url, params)
+      expect(
+        result
+      ).to eq xml
+    end
+
+    it "delegates POST requests to OAuth token instance" do
+      OAuth::AccessToken.any_instance.should_receive(
+        :post
+      ).with(
+        url,
+        params
+      ).and_return(raw)
+
+      result = api.post(url, params)
+      expect(
+        result
+      ).to be_instance_of Gliffy::API::Response
+      expect(result.exists('//g:documents')).to be_true
+    end
+
+    it "delegates signed links generation to OAuth consumer" do
+      signed_url = "mock signed url value"
+
+      OAuth::Consumer.any_instance.should_receive(
+        :create_signed_request
+      ).with(
+        :get,
+        'http://www.gliffy.com/test?param=value',
+        instance_of(OAuth::AccessToken)
+      ).and_return(double(Object, :path => signed_url))
+
+      expect(api.web(url, params)).to eq signed_url
+    end
+  end
+
+  it "allows to impersonate user" do
+    expect(api).to respond_to :impersonate
+  end
+
+  context "when impersonating user" do
+    let(:response) { Gliffy::API::Response.new(fixture("token")) }
+
+    it "sends POST to correct URL" do
+      escaped_user = URI.escape 'test@test.com'
+
+      Gliffy::API::Facade.any_instance.should_receive(
+        :post
+      ).with(
+        "/accounts/#{account_id}/users/#{escaped_user}/oauth_token.xml",
+        hash_including(:action => "create")
+      ).and_return(
+        response
+      )
+
+      api.impersonate("test@test.com")      
+    end
+
+    it "updates OAuth token using server response" do
+      Gliffy::API::Facade.any_instance.should_receive(
+        :post
+      ).and_return(
+        response
+      )
+
+      OAuth::AccessToken.any_instance.should_receive(
+        :token=
+      ).with(
+        "140a1b58c248d13872499df769606766"
+      )
+
+      OAuth::AccessToken.any_instance.should_receive(
+        :secret=
+      ).with(
+        "481830f5827e35b0644a32c1caac5245"
+      )
+
+      api.impersonate("test@test.com")
+    end
+  end
+end