freckle_io 0.0.3

data/spec/freckle_io/client/tags_spec.rb

@@ -0,0 +1,132 @@
+require_relative "../../spec_helper"
+
+describe FreckleIO::Client::Tags do
+  context "with configuration", :vcr do
+    describe "#all" do
+      let(:results) { subject.all }
+      let(:first_response) { results.last_responses.first }
+
+      it "result must be a Request::MultiplePages" do
+        expect(results).to be_a(FreckleIO::Request::MultiplePages)
+      end
+
+      it "returns a tag for each response" do
+        results.last_responses.each do |last_response|
+          expect(last_response.body.first.keys).to eq TAG_KEYS
+        end
+      end
+    end
+
+    # describe "#show" do
+    #   let(:result) { subject.show(ENV["REAL_FRECKLE_TAG_ID"]) }
+    #   let(:response) { result.last_response }
+
+    #   it "get a spacific tag" do
+    #     expect(response.body.keys).to eq(TAG_KEYS)
+    #   end
+
+    #   it "raw links should be a empty array" do
+    #     expect(result.raw_links).to be_empty
+    #   end
+    # end
+
+    describe "with valid params" do
+      let(:params) do
+        {
+          name: "valid_string",
+          billable: true,
+          per_page: 8
+        }
+      end
+
+      let(:results) { subject.all(params) }
+
+      it "params should be valid" do
+        expect do
+          results
+        end.not_to raise_error
+      end
+    end
+
+    describe "with unknow params" do
+      let(:params) do
+        {
+          invalid_params: "oh! oh!"
+        }
+      end
+
+      let(:results) { subject.all(params) }
+
+      it "raises a invalid params error" do
+        expect do
+          results
+        end.to raise_error(FreckleIO::Errors::Params::InvalidParams)
+      end
+    end
+
+    describe "with wrong name" do
+      let(:params) do
+        {
+          name: 123
+        }
+      end
+
+      let(:results) { subject.all(params) }
+
+      it "raises a invalid params error" do
+        expect do
+          results
+        end.to raise_error(FreckleIO::Errors::Params::InvalidParams)
+      end
+    end
+
+    describe "with billable" do
+      let(:params) do
+        {
+          state: 123
+        }
+      end
+
+      let(:results) { subject.all(params) }
+
+      it "raises a invalid params error" do
+        expect do
+          results
+        end.to raise_error(FreckleIO::Errors::Params::InvalidParams)
+      end
+    end
+
+    describe "with validator" do
+      let(:tag_validator) do
+        class_double(
+          FreckleIO::Validator::Tag,
+          errors: {},
+          output: {}
+        )
+      end
+
+      let(:result) do
+        subject.all
+      end
+
+      before do
+        allow(FreckleIO::Validator::Tag).to receive(
+          :validation
+        ).with({}, FreckleIO::Client::Tags::ALLOWED_KEYS) do
+          tag_validator
+        end
+
+        allow(FreckleIO::Validator::Tag).to receive(:errors)
+        allow(FreckleIO::Validator::Tag).to receive(:output)
+
+        result
+      end
+
+      it "call tag's validator" do
+        expect(FreckleIO::Validator::Tag).to have_received(
+          :validation
+        )
+      end
+    end
+  end
+end

data/spec/freckle_io/client/users_spec.rb

@@ -0,0 +1,150 @@
+require_relative "../../spec_helper"
+
+describe FreckleIO::Client::Users do
+  context "with configuration", :vcr do
+    describe "#all" do
+      let(:results) { subject.all }
+      let(:first_response) { results.last_responses.first }
+
+      it "result must be a Request::MultiplePages" do
+        expect(results).to be_a(FreckleIO::Request::MultiplePages)
+      end
+
+      it "returns a user for each response" do
+        results.last_responses.each do |last_response|
+          expect(last_response.body.first.keys).to eq USER_KEYS
+        end
+      end
+    end
+
+    describe "#show" do
+      let(:result) { subject.show(ENV["REAL_FRECKLE_USER_ID"]) }
+      let(:response) { result.last_response }
+
+      it "get a spacific user" do
+        expect(response.body.keys).to eq(USER_KEYS)
+      end
+
+      it "raw links should be a empty array" do
+        expect(result.raw_links).to be_empty
+      end
+    end
+
+    describe "with valid params" do
+      let(:params) do
+        {
+          name: "valid_string",
+          email: "email@domain.com",
+          role: "coworker",
+          state: "active",
+          per_page: 8
+        }
+      end
+
+      let(:results) { subject.all(params) }
+
+      it "params should be valid" do
+        expect do
+          results
+        end.not_to raise_error
+      end
+    end
+
+    describe "with unknow params" do
+      let(:params) do
+        {
+          invalid_params: "oh! oh!"
+        }
+      end
+
+      let(:results) { subject.all(params) }
+
+      it "raises a invalid params error" do
+        expect do
+          results
+        end.to raise_error(FreckleIO::Errors::Params::InvalidParams)
+      end
+    end
+
+    describe "with wrong email" do
+      let(:params) do
+        {
+          email: "invalid_email"
+        }
+      end
+
+      let(:results) { subject.all(params) }
+
+      it "raises a invalid params error" do
+        expect do
+          results
+        end.to raise_error(FreckleIO::Errors::Params::InvalidParams)
+      end
+    end
+
+    describe "with wrong role" do
+      let(:params) do
+        {
+          role: "invalid_role"
+        }
+      end
+
+      let(:results) { subject.all(params) }
+
+      it "raises a invalid params error" do
+        expect do
+          results
+        end.to raise_error(FreckleIO::Errors::Params::InvalidParams)
+      end
+    end
+
+    describe "with state role" do
+      let(:params) do
+        {
+          state: "invalid_state"
+        }
+      end
+
+      let(:results) { subject.all(params) }
+
+      it "raises a invalid params error" do
+        expect do
+          results
+        end.to raise_error(FreckleIO::Errors::Params::InvalidParams)
+      end
+    end
+
+    describe "with validator" do
+      let(:user_validator) do
+        class_double(
+          FreckleIO::Validator::User,
+          errors: {},
+          output: {}
+        )
+      end
+
+      let(:result) do
+        subject.all
+      end
+
+      before do
+        allow(FreckleIO::Validator::User).to receive(
+          :validation
+        ).with({}, FreckleIO::Client::Users::ALLOWED_KEYS) do
+          user_validator
+        end
+
+        allow(FreckleIO::Validator::User).to receive(:errors)
+        allow(FreckleIO::Validator::User).to receive(:output)
+
+        result
+      end
+
+      it "call user's validator" do
+        expect(FreckleIO::Validator::User).to have_received(
+          :validation
+        )
+      end
+    end
+  end
+end

data/spec/freckle_io/configuration_spec.rb

@@ -0,0 +1,70 @@
+require_relative "../spec_helper"
+
+describe FreckleIO::Configuration do
+  context "with right configuration" do
+    before do
+      FreckleIO.reset
+      FreckleIO.configure do |config|
+        config.token = ENV["FRECKLE_TOKEN"]
+        config.url = ENV["FRECKLE_URL"]
+      end
+    end
+
+    it "return the correct token" do
+      expect(
+        FreckleIO.configuration.token
+      ).to eq ENV["FRECKLE_TOKEN"]
+    end
+
+    it "return the correct url" do
+      expect(
+        FreckleIO.configuration.url
+      ).to eq ENV["FRECKLE_URL"]
+    end
+  end
+
+  context "with wrong configuration" do
+    before do
+      FreckleIO.reset
+      FreckleIO.configure do |config|
+        config.auth_type = :wrong_type
+      end
+    end
+
+    it "raises a configuration error for authentication type" do
+      expect do
+        FreckleIO.configuration.auth_type
+      end.to raise_error(FreckleIO::Errors::Configuration)
+    end
+  end
+
+  context "without configuration" do
+    before do
+      FreckleIO.reset
+    end
+
+    it "raises a configuration error for token" do
+      expect do
+        FreckleIO.configuration.token
+      end.to raise_error(FreckleIO::Errors::Configuration)
+    end
+
+    it "raises a configuration error for authentication type" do
+      expect do
+        FreckleIO.configuration.auth_type
+      end.to raise_error(FreckleIO::Errors::Configuration)
+    end
+
+    it "raises a configuration error for max concurrency" do
+      expect do
+        FreckleIO.configuration.max_concurrency
+      end.to raise_error(FreckleIO::Errors::Configuration)
+    end
+
+    it "return default url" do
+      expect(
+        FreckleIO.configuration.url
+      ).to eq FreckleIO::Configuration::DEFAULT_URL
+    end
+  end
+end

data/spec/freckle_io/connection_spec.rb

@@ -0,0 +1,116 @@
+require_relative "../spec_helper"
+
+describe FreckleIO::Connection do
+  context "with default configuration", :vcr do
+    let(:result) { subject.get("/v2/users") }
+
+    describe "with header" do
+      let(:ua) { result.env.request_headers["User-Agent"] }
+
+      it "set user agent" do
+        expect(ua).to eq "MyFreckleBot/1.0"
+      end
+    end
+
+    describe "with freckle token authentication" do
+      let(:header_token) { result.env.request_headers["X-FreckleToken"] }
+
+      it "set X-FreckleToken" do
+        expect(header_token).not_to be nil
+      end
+    end
+
+    describe "with too many request" do
+      # per_page = 1 raise Faraday::ClientError: the server responded
+      # with status 429 (Too Many Requests)
+      #
+      # HTTP/1.1 429 Too Many Requests
+      # Content-Type: text/html
+      # Retry-After: 3600
+      # https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/429
+
+      xit "to implement"
+    end
+
+    describe "with page param" do
+      let(:result) { subject.get("/v2/users", params: {page: 2}) }
+
+      it "response must be success" do
+        expect(result.success?).to be(true)
+      end
+    end
+
+    describe "with per_page param" do
+      let(:per_page) { 8 }
+      let(:result) { subject.get("/v2/users", params: {per_page: per_page}) }
+
+      it "response must have per_page elements" do
+        expect(result.body.count).to eq(per_page)
+      end
+    end
+
+    describe "with invalid url" do
+      let(:invalid_resource) { subject.get("/invalid_url") }
+
+      it "raises a resource not found error for invalid resource" do
+        expect do
+          invalid_resource
+        end.to raise_error(FreckleIO::Errors::Connection::ResourceNotFound)
+      end
+    end
+
+    describe "with a valid response" do
+      it "must be a json format" do
+        expect(result.env.response_headers["Content-Type"]).to eq(
+          "application/json; charset=utf-8"
+        )
+      end
+    end
+  end
+
+  context "with exceptions" do
+    let(:invalid_request) { subject.get("/") }
+
+    describe "with invalid host" do
+      before do
+        allow(Faraday).to receive(:new).once.and_raise(
+          Faraday::ConnectionFailed, "Connection failed"
+        )
+      end
+
+      it "raises a connection error for invalid host" do
+        expect do
+          invalid_request
+        end.to raise_error(FreckleIO::Errors::Connection::Failed)
+      end
+    end
+
+    describe "with invalid resource" do
+      before do
+        allow(Faraday).to receive(:new).once.and_raise(
+          Faraday::ResourceNotFound, "Resource not found"
+        )
+      end
+
+      it "raises a connection error for invalid host" do
+        expect do
+          invalid_request
+        end.to raise_error(FreckleIO::Errors::Connection::ResourceNotFound)
+      end
+    end
+
+    describe "with client error" do
+      before do
+        allow(Faraday).to receive(:new).once.and_raise(
+          Faraday::ClientError, "Client error"
+        )
+      end
+
+      it "raises a connection error for invalid host" do
+        expect do
+          invalid_request
+        end.to raise_error(FreckleIO::Errors::Connection::ClientError)
+      end
+    end
+  end
+end

data/spec/freckle_io/paginator_spec.rb

@@ -0,0 +1,105 @@
+require_relative "../spec_helper"
+
+describe FreckleIO::Paginator do
+  let(:result) { described_class.new(raw_links) }
+
+  describe "#next" do
+    let(:raw_links) do
+      "<https://api.letsfreckle.com/v2/users?page=1>; rel=\"first\",\
+         <https://api.letsfreckle.com/v2/users?page=2>; rel=\"next\""
+    end
+
+    it "returns link of next page" do
+      expect(result.next).to eq("/v2/users?page=2")
+    end
+  end
+
+  describe "#prev" do
+    let(:raw_links) do
+      "<https://api.letsfreckle.com/v2/users?page=1>; rel=\"prev\",\
+         <https://api.letsfreckle.com/v2/users?page=3>; rel=\"next\""
+    end
+
+    it "returns link of previous page" do
+      expect(result.prev).to eq("/v2/users?page=1")
+    end
+  end
+
+  describe "#last" do
+    let(:raw_links) do
+      "<https://api.letsfreckle.com/v2/users?page=1>; rel=\"prev\",\
+         <https://api.letsfreckle.com/v2/users?page=2>; rel=\"last\""
+    end
+
+    it "returns link of previous page" do
+      expect(result.last).to eq("/v2/users?page=2")
+    end
+  end
+
+  describe "#first" do
+    let(:raw_links) do
+      "<https://api.letsfreckle.com/v2/users?page=1>; rel=\"first\",\
+         <https://api.letsfreckle.com/v2/users?page=2>; rel=\"next\""
+    end
+
+    it "returns link of previous page" do
+      expect(result.first).to eq("/v2/users?page=1")
+    end
+  end
+
+  context "without void raw links" do
+    let(:raw_links) { "" }
+
+    describe "#next" do
+      it "return nil" do
+        expect(result.next).to eq(nil)
+      end
+    end
+
+    describe "#prev" do
+      it "return nil" do
+        expect(result.prev).to eq(nil)
+      end
+    end
+
+    describe "#last" do
+      it "return nil" do
+        expect(result.last).to eq(nil)
+      end
+    end
+
+    describe "#first" do
+      it "return nil" do
+        expect(result.first).to eq(nil)
+      end
+    end
+  end
+
+  context "without empty array raw links" do
+    let(:raw_links) { [] }
+
+    describe "#next" do
+      it "return nil" do
+        expect(result.next).to eq(nil)
+      end
+    end
+
+    describe "#prev" do
+      it "return nil" do
+        expect(result.prev).to eq(nil)
+      end
+    end
+
+    describe "#last" do
+      it "return nil" do
+        expect(result.last).to eq(nil)
+      end
+    end
+
+    describe "#first" do
+      it "return nil" do
+        expect(result.first).to eq(nil)
+      end
+    end
+  end
+end

data/spec/freckle_io/params_spec.rb

@@ -0,0 +1,15 @@
+require_relative "../spec_helper"
+
+describe FreckleIO::Params do
+  context "when invalid module" do
+    subject do
+      described_class.new({}, nil, "invalid_module").call
+    end
+
+    it "raises a invalid module error" do
+      expect do
+        subject
+      end.to raise_error(FreckleIO::Errors::Params::InvalidModule)
+    end
+  end
+end

data/spec/freckle_io/request/multiple_pages_spec.rb

@@ -0,0 +1,39 @@
+require_relative "../../spec_helper"
+
+describe FreckleIO::Request::MultiplePages do
+  context "with configuration", :vcr do
+    let(:result) { subject.get("/v2/users") }
+    let(:default_per_page) { 30 }
+
+    describe "#get" do
+      let(:last_responses) { result.last_responses }
+
+      it "returns an array of faraday response" do
+        expect(last_responses).to all(be_a(Faraday::Response))
+      end
+
+      it "returns freckle default per page elements" do
+        expect(last_responses.first.body.count).to eq(default_per_page)
+      end
+    end
+  end
+
+  context "with per page", :vcr do
+    before do
+      FreckleIO.configure do |config|
+        config.per_page = per_page
+      end
+    end
+
+    let(:per_page) { 19 }
+    let(:result) { subject.get("/v2/users") }
+
+    describe "#get" do
+      let(:last_responses) { result.last_responses }
+
+      it "return per page number elements" do
+        expect(last_responses.first.body.count).to eq(per_page)
+      end
+    end
+  end
+end