tco_client_core 0.1.3 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bb7e85db0f524ca8d6aea9f9501d3b6a3c8d3d5e
-  data.tar.gz: bb730570d3131439cc7ca55ad6fa25e5121affc3
+  metadata.gz: 988aa36ca352a04d8301597ea64143f36ce78971
+  data.tar.gz: 7dd34b6afb2fd308003a9a0322ac4a2e44219f17
 SHA512:
-  metadata.gz: d32fa588db99fb5745e8116e2aa5509708636a93f52341bea4757e53f4cf849dbf2459cea66913a195119734066791d87bf1749eca1324e8fb8771bd7cb7031a
-  data.tar.gz: 641a5f4879038e5f005cd51ca9016ad39495c65c97e057f2934217bb10a79ceeb17654d5ba3018542d8493b335e24fa1c309b1ec3a3189c4eab7a3e405694484
+  metadata.gz: a03da0c76691340140a2dd11d774c83a91f89c1f415f88369b2b6faf453324f46e978ff55ec4776d04aab7d2321fa29ca1030db06b2429fdc8b3bcad834e78f6
+  data.tar.gz: 2605a74f0b59bb4e3de9236f24c697aac30098fdb954a64a5c29c8bc72c505f7b95e0da399848e2f0dbee830eeb578df5cb85b23b2bfd872a0c8018c485028d9

data/lib/tco_client_core/base_request.rb

@@ -21,12 +21,12 @@ module TcoClientCore
         payload: payload.to_json,
         headers: {
           accept: :json,
-          content_type: 'application/json',
+          content_type: "application/json",
           authorization: authorization
         }
       }
 
-      response = TcoClientCore::Response.new(RestClient::Request.new(params).execute)
+      TcoClientCore::Response.new(RestClient::Request.new(params).execute)
     end
 
     def self.get(endpoint, options={})

data/lib/tco_client_core/response.rb

@@ -1,55 +1,27 @@
-require "ostruct"
 require "json"
 
 module TcoClientCore
   class Response
-    def self.to_struct(object)
-      if object.is_a? Array
-        object.map { |v| to_struct(v) }
-      elsif object.is_a? Hash
-        object.each_with_object(OpenStruct.new) do |(key, val), st|
-          st[key] = to_struct(val)
-        end
-      else
-        object
-      end
-    end
+    extend Forwardable
 
-    attr_reader :raw, :to_struct
+    def_delegators :@response, :to_h, :to_hash
 
-    def initialize(response)
-      @raw = response
-      errors.each do |key, value|
-        if key == "ActiveRecord::RecordNotFound"
-          raise TcoClientCore::RecordNotFound, value.first
-        end
+    def initialize(raw)
+      @raw = raw
+      @response = JSON.parse(raw)
+      raise ArgumentError, "TcoClientCore::Response: response hash required" unless @response.is_a? Hash
+      @response.keys.each do |key|
+        next if key == "errors"
+        define_singleton_method(key) { @response[key] }
       end
-      @to_struct = self.class.to_struct(as_json)
-    end
-
-    def to_json
-      to_s
-    end
-
-    def as_json
-      JSON.parse(raw)
-    end
-
-    def to_s
-      raw.to_s
     end
 
     def errors?
-      json = as_json
-      !!(json.is_a?(Hash) && (json.fetch("errors", nil) || json.fetch(:errors, nil)))
+      @response.key?("errors")
     end
 
     def errors
-      if errors?
-        as_json["errors"] || as_json[:errors]
-      else
-        {}
-      end
+      @response.fetch("errors", {})
     end
   end
 end

data/lib/tco_client_core/version.rb

@@ -1,3 +1,3 @@
 module TcoClientCore
-  VERSION = "0.1.3"
+  VERSION = "0.2.0"
 end

data/spec/response_spec.rb

@@ -1,124 +1,44 @@
 require "spec_helper"
 
 describe TcoClientCore::Response do
-  let(:raw_response) { { test: "response" }.to_json }
-  subject { TcoClientCore::Response.new(raw_response) }
+  let(:hash) { { "a" => "A", "b" => "B" } }
+  subject { TcoClientCore::Response.new(hash.to_json) }
 
-  it "saves a reference to the raw response" do
-    expect(subject.raw).to eq(raw_response)
+  it "raises an error when given a json array" do
+    expect {
+      TcoClientCore::Response.new("[]")
+    }.to raise_error ArgumentError
   end
 
-  describe "#to_s" do
-    it "returns the raw response string" do
-      expect(subject.to_s).to eq(raw_response)
-    end
-  end
-
-  describe "#to_json" do
-    it "returns the raw json" do
-      expect(subject.to_json).to eq(raw_response)
-    end
+  it "defines methods for each key in the response hash" do
+    expect(subject.a).to eq("A")
+    expect(subject.b).to eq("B")
   end
 
-  describe "#as_json" do
-    it "returns the response as json" do
-      expect(subject.as_json).to have_key("test")
-    end
-  end
-
-  describe "#to_struct" do
-    context "with a hash" do
-      it "creates an open struct" do
-        ostruct = subject.to_struct
-        expect(ostruct).to be_kind_of(OpenStruct)
-      end
-
-      it "creates a open struct for nested hashes" do
-        subject = TcoClientCore::Response.new({
-          one: 1,
-          two: { three: { four: 4 } }
-        }.to_json)
-
-        ostruct = subject.to_struct
-        expect(ostruct[:two]).to be_kind_of(OpenStruct)
-        expect(ostruct.two.three.four).to eq(4)
-      end
-
-      it "creates a open struct for array values with hashes" do
-        subject = TcoClientCore::Response.new({
-          one: 1,
-          two: { three: [{ four: 4 }] }
-        }.to_json)
-        ostruct = subject.to_struct
-        expect(ostruct.two.three.first).to be_kind_of(OpenStruct)
-      end
-
-      context "with nil values" do
-        subject { TcoClientCore::Response.new({ test: nil }.to_json) }
-
-        it "does not create an infinite loop" do
-          expect { subject.to_struct }.not_to raise_error
-        end
-      end
+  describe "#to_h" do
+    it "returns the response json hash" do
+      expect(subject.to_h).to include(hash)
     end
 
-    context "with an array" do
-      it "creates a open struct for every hash property" do
-        subject = TcoClientCore::Response.new([{ one: 1 }, { two: 2 }].to_json)
-
-        array = subject.to_struct;
-        expect(array.first).to be_kind_of(OpenStruct)
-        expect(array.last).to be_kind_of(OpenStruct)
-      end
-
-      it "creates a open struct for nested arrays with hashes" do
-        subject = TcoClientCore::Response.new([
-          { one: 1 },
-          [{ two: 2 }]
-        ].to_json)
-
-        array = subject.to_struct
-        expect(array.last.first).to be_kind_of(OpenStruct)
-      end
-
-      context "with nil values" do
-        subject { TcoClientCore::Response.new([nil].to_json) }
-
-        it "does not create an infinite loop" do
-          expect { subject.to_struct }.not_to raise_error
-        end
-      end
+    it "is aliased as to_hash" do
+      expect(subject.to_hash).to include(hash)
     end
   end
 
   describe "#errors?" do
-    context "without errors" do
-      it "returns false" do
-        expect(subject.errors?).to eq(false)
-      end
+    it "returns false when an errors key is missing" do
+      expect(subject.errors?).to eq(false)
     end
 
-    context "with errors" do
-      subject { TcoClientCore::Response.new({ errors: { field: ["error message"] } }.to_json) }
-
-      it "return true" do
-        expect(subject.errors?).to eq(true)
-      end
+    it "returns true when an errors key is present" do
+      subject = TcoClientCore::Response.new({ errors: { foo: ["message"] } }.to_json)
+      expect(subject.errors?).to eq(true)
     end
   end
 
   describe "#errors" do
-    subject { TcoClientCore::Response.new({ errors: { field: ["error message"] } }.to_json) }
-
-    it "returns the errors key" do
-      expect(subject.errors).to have_key("field")
-    end
-  end
-
-  describe "with exceptions" do
-    it "raises a TcoClientCore::RecordNotFound exception if the record was not found" do
-      allow_any_instance_of(RestClient::Request).to receive(:execute).and_return({ "errors" => { "ActiveRecord::RecordNotFound" => ["not found error"] } }.to_json)
-      expect { TcoClientCore::BaseRequest.request("test", :get) }.to raise_error(TcoClientCore::RecordNotFound)
+    it "returns an empty hash when there are no errors" do
+      expect(subject.errors).to eq({})
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tco_client_core
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0
 platform: ruby
 authors:
 - 2CO Inc
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-19 00:00:00.000000000 Z
+date: 2015-05-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -255,7 +255,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.3
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Gem to handle communication with the 2CO API
@@ -264,3 +264,4 @@ test_files:
 - spec/response_spec.rb
 - spec/spec_helper.rb
 - spec/tco_base_api_spec.rb
+has_rdoc: