syncano 4.0.0.alpha1 → 4.0.0.alpha2

data/spec/unit/connection_spec.rb

@@ -7,131 +7,68 @@ describe Syncano::Connection do
     specify { expect(described_class.new).to_not be_authenticated }
   end
 
-  describe '#request' do
-    let(:headers) { { 'X-Api-Key'=>'87a7da987da98sd7a98', 'User-Agent' => "Syncano Ruby Gem #{Syncano::VERSION}" } }
-    let(:api_key) { '87a7da987da98sd7a98' }
-
-    subject { described_class.new(api_key: api_key) }
-
-    context 'called with unsupported method' do
-      specify do
-        expect { subject.request :koza, 'fafarafa' }.
-          to raise_error(RuntimeError, 'Unsupported method "koza"')
-      end
-    end
-
-    context 'called with supported method' do
-      before do
-        stub_request(:get, endpoint_uri('somepath/')).
-          with(headers: headers).
-          to_return(body: generate_body(some: 'response'))
-      end
-
-      specify do
-        expect(subject.request(:get, 'somepath/')).to eq('some' => 'response')
-      end
-    end
-
-    context 'called with supported method returning a a client error' do
-      before do
-        stub_request(:post, endpoint_uri('instances/')).
-          with(body: { 'name' => 'koza' },
-               headers: headers).
-          to_return(body: generate_body({name: ['This field can not be "koza"']}),
-                    status: 400)
-      end
+  describe '#authenticate' do
+    subject { described_class.new email: email, password: password }
 
-      specify do
-        expect { subject.request(:post, '/v1/instances/', { name: "koza" }) }.
-            to raise_error(Syncano::ClientError)
-      end
-    end
+    let(:authenticate_uri) { endpoint_uri('account/auth/') }
+    let(:email) { 'kiszka@koza.com' }
+    let(:password) { 'kiszonka' }
+    let(:success_status) { 200 }
+    let(:unauthorized_status) { 401 }
 
-    context 'returning a server error' do
+    context 'successful' do
       before do
-        stub_request(:get, endpoint_uri('error_prone/')).
-          to_return(body: 'An error occured', status: 500)
+        expect(subject).to receive(:request).
+          with(:post, described_class::AUTH_PATH, email: email, password: password).
+          and_return('account_key' => 'kEy')
       end
 
       specify do
-        expect { subject.request(:get, endpoint_uri('error_prone/'), nil) }.
-          to raise_error(Syncano::ServerError)
+        expect { subject.authenticate }.to change { subject.authenticated? }
       end
     end
 
-    context 'returning unsupported status code' do
+    context 'failed' do
       before do
-        stub_request(:get, endpoint_uri('weird/')).to_return(body: 'O HAI!', status: 101)
-      end
-
-      specify do
-        expect { subject.request(:get, endpoint_uri('weird/')) }.to raise_error(Syncano::UnsupportedStatusError)
-      end
-    end
+        expect(subject).to receive(:request).and_raise('auth failed')
 
-    context 'successful returning empty body' do
-      before do
-        stub_request(:delete, endpoint_uri('instances/kiszonka/')).
-          with(headers: headers).
-          to_return(body: nil, status: 204)
       end
 
       specify do
-        expect { subject.request(:delete, '/v1/instances/kiszonka/', {}) }.
-          to_not raise_error
+        expect { subject.authenticate }.to raise_error('auth failed')
       end
-
     end
   end
 
-  describe '#authenticate' do
-    subject { described_class.new }
+  describe '#request' do
+    let(:headers) { { 'X-Api-Key'=>'87a7da987da98sd7a98', 'User-Agent' => "Syncano Ruby Gem #{Syncano::VERSION}" } }
+    let(:api_key) { '87a7da987da98sd7a98' }
+    let(:connection_params) { { api_key: api_key, user_key: 'Us3rK3y' } }
+    let(:raw_response) { { body: 'koza' } }
+    let(:handled_response) { double :handled_response }
 
-    let(:authenticate_uri) { endpoint_uri('account/auth/') }
-    let(:email) { 'kiszka@koza.com' }
-    let(:password) { 'kiszonka' }
-    let(:success_status) { 200 }
-    let(:unauthorized_status) { 401 }
+    subject { described_class.new(connection_params) }
 
-    context 'successful' do
+    context 'with supported method' do
       before do
-        stub_request(:post, authenticate_uri).
-          with(body: { 'email' => email, 'password' => password } ).
-          to_return(body: successful_body, status: success_status)
-      end
+        stub_request(:get, endpoint_uri('user/method/')).
+          with(headers: headers).to_return(raw_response)
 
-      it 'should get an API key' do
-        expect { subject.authenticate(email, password) }.to change { subject.authenticated? }
+        expect(Syncano::Response).
+          to receive(:handle) { |raw_response| expect(raw_response.body).to eq('koza') }.
+               and_return(handled_response)
       end
 
-      def successful_body
-        generate_body id: 15,
-          email: email,
-          first_name: '',
-          last_name: '',
-          account_key: 'kozakoza123'
+      specify do
+        expect(subject.request(:get, 'user/method/')).to eq(handled_response)
       end
     end
 
-    context 'failed' do
-      before do
-        stub_request(:post, authenticate_uri).
-          with(body: { 'email' => email, 'password' => password }).
-          to_return(body: failed_body, status: unauthorized_status)
-
-      end
-
-      it 'should raise an exception' do
-        expect { subject.authenticate(email, password) }.to raise_error(Syncano::ClientError)
-      end
-
-      def failed_body
-        generate_body detail: 'Invalid email or password.'
+    context 'with unsupported method' do
+      specify do
+        expect { subject.request :koza, 'fafarafa' }.
+          to raise_error(RuntimeError, 'Unsupported method "koza"')
       end
     end
   end
-
-  def generate_body(params)
-    JSON.generate params
-  end
 end

data/spec/unit/resources/paths_spec.rb

@@ -0,0 +1,21 @@
+require_relative '../../spec_helper'
+
+describe ::Syncano::Resources::Paths do
+  let(:koza) { double 'KozaClass' }
+
+  context 'collections' do
+    subject { described_class.instance.collections }
+
+    before { subject.define '/kozas/{koza_name}/kiszkas/', koza }
+
+    specify { expect(subject.match('/kozas/mykoza/kiszkas/')).to eq(koza) }
+  end
+
+  context 'members' do
+    subject { described_class.instance.members }
+
+    before { subject.define '/kozas/{koza_name}/', koza }
+
+    xspecify { expect(subject.match('kozas/mykoza/')).to eq(koza) }
+  end
+end

data/spec/unit/resources_base_spec.rb

@@ -74,7 +74,7 @@ describe Syncano::Resources::Base do
                                          { 'type' => 'list',
                                           'name' => 'webhooks' }] },
            :collection => { :path => '/v1/instances/',
-                           :http_methods => ['post',
+                            :http_methods => ['post',
                                              'get'],
                            :params => [] },
            :member => { :path => '/v1/instances/{ name }/',
@@ -140,7 +140,7 @@ describe Syncano::Resources::Base do
     end
 
     it 'should init attributes' do
-      resource = subject.new(connection, {}, { name: 'test' }, true)
+      resource = subject.new(connection, {}, { name: 'test' })
       expect(resource.name).to eq('test')
     end
 
@@ -153,33 +153,94 @@ describe Syncano::Resources::Base do
       resource = subject.new(connection, {}, { links: { self: '/v1/instances/test/' }, name: 'test' }, false)
       expect(resource.changed?).to eq(true)
     end
+  end
+
+  describe '#new_record?' do
+    let(:resource) { subject.new connection, {}, { name: 'asd' }, from_db }
+
+    context 'is true' do
+      let(:from_db) { false }
 
-    it 'should mark resource as not new if initialized with self path' do
-      resource = subject.new(connection, {}, { links: { self: '/v1/instances/test/' } }, true)
-      expect(resource.new_record?).to be(false)
+      specify { expect(resource.new_record?).to eq(true) }
     end
 
-    it 'should mark resource as new if initialized without self path' do
-      resource = subject.new(connection, {}, { name: 'test' }, true)
-      expect(resource.new_record?).to be(true)
+    context 'is false' do
+      let(:from_db) { true }
+
+      specify { expect(resource.new_record?).to eq(false) }
     end
   end
 
-  describe '.create' do
-    it 'should create new object in Syncano' do
+  describe "persisting data" do
+    shared_context "resource invalid" do
+      before { expect(resource).to receive(:valid?) { false } }
+    end
+
+    shared_context "resource valid" do
+      before do
+        # expect(instance_of(Syncano::Resource::Base)).to receive(:valid?) { true }
+
+        expect(resource).to receive(:valid?) { true }
 
+        expect(connection).to receive(:request).
+                                with(instance_of(Symbol), instance_of(String), instance_of(Hash)).
+                                and_return({})
+      end
     end
-  end
 
-  describe '.update_attributes' do
-    it 'should create update object\'s attributes in Syncano' do
+    let(:resource) { subject.new connection, {}, {}, false }
 
+    describe ".create!" do
+      before do
+        expect(subject).to receive(:new).and_return(resource)
+        expect(resource).to receive(:save!).and_return(resource)
+      end
+
+      specify { expect(subject.create!(connection, {}, {})).to eq(resource) }
     end
-  end
 
-  describe '.destroy' do
-    it 'should delete object from Syncano' do
+    describe ".create" do
+      before do
+        expect(subject).to receive(:new).and_return(resource)
+        expect(resource).to receive(:save).and_return(false)
+      end
+
+      specify { expect(subject.create(connection, {}, {})).to eq(resource) }
+      specify { expect(subject.create(connection, {}, {}).new_record?).to eq(true) }
+    end
+
+    describe "#save" do
+      context "when invalid" do
+        include_context "resource invalid"
+
+        specify { expect(resource.save).to eq(false) }
+      end
+
+      context "when valid" do
+        include_context "resource valid"
+
+        specify { expect(resource.save).to be_kind_of(Syncano::Resources::Base) }
+      end
+    end
+
+    describe "#save!" do
+      context "when invalid" do
+        include_context "resource invalid"
+
+        specify do
+          expect {
+            resource.save!
+          }.to raise_error(Syncano::Resources::ResourceInvalid)
+        end
+      end
+
+      context "when valid" do
+        include_context "resource valid"
 
+        specify do
+          expect(resource.save!).to be_kind_of(Syncano::Resources::Base)
+        end
+      end
     end
   end
 end

data/spec/unit/response_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+describe Syncano::Response do
+  describe '.handle' do
+    context 'success' do
+      let(:raw_response) { double :raw_response,
+                                  body: generate_body(some: 'response'),
+                                  status: status(200) }
+
+      specify do
+        expect(described_class.handle(raw_response)).to eq('some' => 'response')
+      end
+    end
+
+    context 'not found' do
+      let(:env) { double :env, url: 'http://path', method: :get }
+      let(:raw_response) { double :raw_response,
+                                  body: nil,
+                                  status: status(404),
+                                  env: env }
+
+      specify do
+        expect { described_class.handle(raw_response) }.to raise_error(Syncano::NotFound)
+      end
+    end
+
+    context 'client error' do
+      let(:raw_response) {
+        double :raw_response, body: generate_body({name: ['This field can not be "koza"']}),
+          status: status(400)
+      }
+
+      specify do
+        expect { described_class.handle(raw_response) }.to raise_error(Syncano::ClientError)
+      end
+    end
+
+    context 'returning a server error' do
+      let(:raw_response) { double :raw_response,
+                                  body: 'server error',
+                                  status: status(500) }
+
+      specify do
+        expect { described_class.handle(raw_response) }.
+          to raise_error(Syncano::ServerError)
+      end
+    end
+
+    context 'unsupported status code' do
+      let(:raw_response) { double :raw_response,
+                            body: 'fafarafa',
+                            status: status(112) }
+
+      specify do
+        expect { described_class.handle(raw_response) }.to raise_error(Syncano::UnsupportedStatusError)
+      end
+    end
+
+    context 'successful returning empty body' do
+      let(:raw_response) { double :raw_response, status: status(204) }
+
+      specify do
+        expect(described_class.handle(raw_response)).to eq(nil)
+      end
+    end
+  end
+
+  def generate_body(params)
+    JSON.generate params
+  end
+
+  def status(code)
+    double :status, code: code
+  end
+end

data/spec/unit/schema/resource_definition_spec.rb

@@ -22,4 +22,14 @@ describe Syncano::Schema::ResourceDefinition do
   it 'should delete colliding links' do
     expect(definition[:associations]['links']).to be_empty
   end
+
+  describe 'top_level?' do
+    context "when is top level" do
+      pending "to be done"
+    end
+
+    context "when is not top level" do
+      pending "to be done"
+    end
+  end
 end

data/spec/unit/schema_spec.rb

@@ -1,66 +1,16 @@
 require_relative '../spec_helper'
 
-
-require 'rspec/expectations'
-require 'active_attr/matchers/have_attribute_matcher'
-require 'shoulda-matchers'
-
 describe Syncano::Schema do
-  include ActiveAttr::Matchers
-
-  let(:connection) { double("connection") }
-
-  subject { described_class.new connection }
+  let(:connection) { double 'connection' }
 
   before do
-    expect(connection).to receive(:request).with(:get, described_class::SCHEMA_PATH) { schema }
-
-    Syncano::Resources.instance_eval do
-      constants.each do |const|
-        if ![:Base, :Collection, :Space].include?(const) && const_defined?(const)
-          remove_const const
-        end
-      end
-    end
+    expect(connection).to receive(:request).with(:get, described_class.schema_path) { schema }
   end
 
-  describe 'process!' do
-    it 'defintes classes according to the schema' do
-      expect { Syncano::Resources::Class }.to raise_error(NameError)
-
-      subject.process!
-
-      expect { Syncano::Resources::Class }.to_not raise_error
-
-      expect(Syncano::Resources::Class).to have_attribute(:name)
-      expect(Syncano::Resources::Class).to have_attribute(:status)
-      expect(Syncano::Resources::Class).to have_attribute(:created_at)
-      expect(Syncano::Resources::Class).to have_attribute(:description)
-      expect(Syncano::Resources::Class).to have_attribute(:updated_at)
-      expect(Syncano::Resources::Class).to have_attribute(:objects_count)
-      expect(Syncano::Resources::Class).to have_attribute(:metadata)
-      expect(Syncano::Resources::Class).to have_attribute(:revision)
-
-      class_instance = Syncano::Resources::Class.new(connection, {}, { links: {} })
-
-      expect(class_instance).to validate_presence_of(:name)
-      expect(class_instance).to validate_length_of(:name).is_at_most(50)
-
-      expect(class_instance).to respond_to(:objects)
-
-      code_box_instance = Syncano::Resources::CodeBox.new(connection, {}, { links: {} })
-      expect(code_box_instance).to validate_inclusion_of(:runtime_name).
-                                             in_array(%w(nodejs ruby python))
-
-    end
-
-    it 'defines foreign keys attributes when attributes names collide with links' do
-      subject.process!
-
-      schedule_instance = Syncano::Resources::Schedule.new connection, {}, links: {}
+  subject { described_class.new(connection) }
 
-      expect(schedule_instance).to respond_to(:codebox)
-    end
+  specify '#resource_definitions' do
+    expect(subject.definition).to be_kind_of(Hash)
   end
 
   def schema