syncano 4.0.0.alpha1 → 4.0.0.alpha2

data/lib/syncano/schema.rb

@@ -1,35 +1,26 @@
 require_relative './schema/attribute_definition'
 require_relative './schema/resource_definition'
+require_relative './schema/endpoints_whitelist'
+
+require 'singleton'
 
 module Syncano
   class Schema
-    SCHEMA_PATH = 'schema/'
 
     attr_reader :schema
 
-    def initialize(connection)
-      self.connection = connection
-      load_schema
+    def self.schema_path
+      "/#{Syncano::Connection::API_VERSION}/schema/"
     end
 
-    def process!
-      schema.each do |name, raw_resource_definition|
-        resource_definition = Syncano::Schema::ResourceDefinition.new(name, raw_resource_definition)
-        resource_class = ::Syncano::Resources.define_resource_class(resource_definition)
-
-        if resource_definition[:collection].present? && resource_definition[:collection][:path].scan(/\{([^}]+)\}/).empty?
-          self.class.generate_client_method(name, resource_class)
-        end
-      end
+    def initialize(connection = ::Syncano::Connection.new)
+      self.connection = connection
     end
 
-    private
-
     attr_accessor :connection
-    attr_writer :schema
 
-    def load_schema
-      raw_schema = connection.request(:get, SCHEMA_PATH)
+    def definition
+      raw_schema = connection.request(:get, self.class.schema_path)
       resources = {}
 
       raw_schema.each do |resource_schema|
@@ -70,17 +61,7 @@ module Syncano
         end
       end
 
-      self.schema = resources
-    end
-
-    class << self
-      def generate_client_method(resource_name, resource_class)
-        method_name = resource_name.tableize
-
-        ::Syncano::API.send(:define_method, method_name) do
-          ::Syncano::QueryBuilder.new(connection, resource_class)
-        end
-      end
+      resources
     end
   end
 end

data/lib/syncano/schema/attribute_definition.rb

@@ -22,8 +22,8 @@ module Syncano
         set_default
       end
 
-      def force_default?
-        !default.nil?
+      def validate?
+        writable? && required?
       end
 
       def writable?

data/lib/syncano/schema/endpoints_whitelist.rb

@@ -0,0 +1,40 @@
+module Syncano
+  class Schema
+    class EndpointsWhitelist
+      include Enumerable
+
+      class SupportedDefinitionPredicate
+        attr_accessor :definition
+
+        def initialize(definition)
+          self.definition = definition
+        end
+
+        def call
+          path =~ /\A\/v1\/instances/ && path !~ /invitation/
+        end
+
+        private
+
+        def path
+          definition[:collection] && definition[:collection][:path] ||
+            definition[:member] && definition[:member][:path]
+        end
+      end
+
+      SUPPORTED_DEFINITIONS = -> (definition) {
+        SupportedDefinitionPredicate.new(definition).call
+      }
+
+      def initialize(schema)
+        @definition = schema.definition
+      end
+
+      def each(&block)
+        @definition.select { |_name, definition|
+          SUPPORTED_DEFINITIONS === definition
+        }.each &block
+      end
+    end
+  end
+end

data/lib/syncano/schema/resource_definition.rb

@@ -20,6 +20,11 @@ module Syncano
         @raw_definition[key]
       end
 
+      def top_level?
+        @raw_definition[:collection].present? &&
+          @raw_definition[:collection][:path].scan(/\{([^}]+)\}/).empty?
+      end
+
       private
 
       def delete_colliding_links

data/lib/syncano/upload_io.rb

@@ -0,0 +1,7 @@
+module Syncano
+  class UploadIO < Faraday::UploadIO
+    def initialize(path)
+      super path, File.mime_type?(File.new(path))
+    end
+  end
+end

data/lib/syncano/version.rb

@@ -1,3 +1,3 @@
 module Syncano
-  VERSION = '4.0.0.alpha1'
+  VERSION = '4.0.0.alpha2'
 end

data/spec/integration/syncano_spec.rb

@@ -4,23 +4,28 @@ WebMock.allow_net_connect!
 
 describe Syncano do
   before(:all) do
+    Syncano::API.send :initialized=, false
+
     @api_key = ENV['INTEGRATION_TEST_API_KEY']
     @api = Syncano.connect(api_key: @api_key)
   end
 
   before(:each) do
     @api.instances.all.each &:destroy
-    @instance = @api.instances.create(name: "a#{SecureRandom.hex(24)}")
+    @instance = @api.instances.create(name: instance_name )
     @instance.classes.all.select { |c| c.name != 'user_profile'}.each &:destroy
     @instance.groups.all.each &:destroy
     @instance.users.all.each &:delete
   end
 
+  let(:instance_name) { "a#{SecureRandom.hex(24)}" }
+  let(:group) { @instance.groups.create name: 'wheel' }
+
   describe 'working with instances' do
     subject { @api.instances }
 
     it 'should raise an error on not found instance' do
-      expect { subject.find('kaszanka') }.to raise_error(Syncano::ClientError)
+      expect { subject.find('kaszanka') }.to raise_error(Syncano::NotFound)
     end
 
     specify do
@@ -62,7 +67,6 @@ describe Syncano do
 
     subject { @class.objects }
 
-
     specify 'basic operations' do
       expect { subject.create currency: 'USD', ballance: 1337 }.to create_resource
 
@@ -79,9 +83,6 @@ describe Syncano do
       expect(object.currency).to eq('GBP')
 
       expect { subject.destroy(object.primary_key) }.to destroy_resource
-      expect {
-        subject.destroy(object.primary_key)
-      }.to raise_error(Syncano::ClientError, /not found/i)
     end
 
 
@@ -161,7 +162,7 @@ describe Syncano do
 
 
     specify 'basic operations' do
-      expect { subject.create name: 'df', source: 'puts 1337', runtime_name: 'ruby' }.to create_resource
+      expect { subject.create label: 'df', source: 'puts 1337', runtime_name: 'ruby' }.to create_resource
 
       codebox = subject.first
       codebox.run
@@ -169,7 +170,7 @@ describe Syncano do
       codebox.save
       codebox.run
 
-      without_profiling { sleep 5 }
+      without_profiling { sleep 10 }
       traces = codebox.traces.all
 
       expect(traces.count).to eq(2)
@@ -177,13 +178,13 @@ describe Syncano do
       first = traces[1]
 
       expect(first.status).to eq('success')
-      expect(first.result).to eq('1337')
+      expect(first.result["stdout"]).to eq('1337')
 
       second = traces[0]
       expect(second.status).to eq('success')
-      expect(second.result).to eq('123')
+      expect(second.result["stdout"]).to eq('123')
 
-      expect { @instance.schedules.create name: 'test', interval_sec: 30, codebox: codebox.primary_key }.
+      expect { @instance.schedules.create label: 'test', interval_sec: 30, codebox: codebox.primary_key }.
           to change { @instance.schedules.all.count }.by(1)
 
       expect { codebox.destroy }.to destroy_resource
@@ -193,14 +194,218 @@ describe Syncano do
   describe 'working with webhooks' do
     subject { @instance.webhooks }
 
-    let!(:codebox) { @instance.codeboxes.create name: 'wurst', source: 'puts "currywurst"', runtime_name: 'ruby' }
+    describe 'using the gem' do
+      let!(:codebox) { @instance.codeboxes.create label: 'wurst', source: 'puts "currywurst"', runtime_name: 'ruby' }
+
+      specify do
+        expect { subject.create name: 'web-wurst', codebox: codebox.primary_key }.to create_resource
+
+        expect(subject.first.run['result']["stdout"]).to eq('currywurst')
+
+        expect { subject.first.destroy }.to destroy_resource
+      end
+    end
+
+    describe 'using curl' do
+      let(:source) {
+        <<-SOURCE
+          p ARGS["POST"]
+        SOURCE
+      }
+      let!(:codebox) { @instance.codeboxes.create label: 'curl', source: source, runtime_name: 'ruby' }
+      let!(:webhook) { subject.create name: 'web-curl', codebox: codebox.primary_key, public: true }
+
+      specify do
+        url = "#{ENV['API_ROOT']}/v1/instances/#{instance_name}/webhooks/p/#{webhook.public_link}/"
+        code = %{curl -k --form kiszka=koza -H "kiszonka: 007" -X POST #{url} 2>/dev/null}
+        output = JSON.parse(`#{code}`)
+
+        expect(output["status"]).to eq("success")
+        expect(output["result"]["stdout"]).to eq('{"kiszka"=>"koza"}')
+      end
+    end
+  end
+
+  describe 'working with API keys' do
+    subject { @instance.api_keys }
+
+    specify do
+      api_key = nil
+
+      expect {
+        api_key = subject.create allow_user_create: true
+      }.to create_resource
+
+      expect { api_key.destroy }.to destroy_resource
+    end
+  end
+
+  describe 'managing users' do
+    subject { @instance.users }
+
+    let(:user_profile) { @instance.classes.find("user_profile") }
+
+    before do
+      user_profile.schema = [{ name: "nickname", type: "text" },
+                             { name: "resume", type: "file" }]
+      user_profile.save
+    end
+
+    specify do
+      user = nil
+
+      expect {
+        user = subject.create(username: 'koza', password: 'kiszkakoza')
+      }.to create_resource
+
+      user.update_attributes username: 'kiszka'
+      expect(subject.find(user.primary_key).username).to eq('kiszka')
+
+
+      profile =  @instance.classes.find("user_profile").objects.find(1)
+      profile.nickname = "k0z4"
+      profile.resume = Syncano::UploadIO.new(File.absolute_path(__FILE__))
+      profile.save
+
+      expect(profile.nickname).to eq("k0z4")
+
+      expect { user.destroy }.to destroy_resource
+    end
+  end
+
+
+  describe 'managing groups' do
+    subject { @instance.groups }
+
+    specify do
+      creator = @instance.users.create username: 'content', password: 'creator'
+
+      content_creators = nil
+
+      expect {
+        content_creators = subject.create label: 'content creators'
+      }.to create_resource
+
+      expect {
+        content_creators.users.create user: creator.primary_key
+      }.to change { content_creators.users.all.count }.from(0).to(1)
+
+      expect { content_creators.destroy }.to destroy_resource
+    end
+  end
+
+  describe 'managing channels' do
+    subject do
+      @instance.channels
+    end
+
+    specify do
+      channel = nil
+      expect { channel = subject.create(name: 'chat') }.to create_resource
+      expect { channel.destroy }.to destroy_resource
+    end
+  end
+
+
+  describe 'subscribing to a channel' do
+    before(:each) { Celluloid.boot }
+
+    after(:each) { Celluloid.shutdown }
+
+    let!(:notifications) do
+      @instance.classes.create(name: 'notifications', schema: [{name: 'message', type: 'string'}]).objects
+    end
+
+    let!(:notifications_channel) do
+      @instance.channels.create name: 'system-notifications', other_permissions: 'subscribe'
+    end
+
+    specify do
+      poller = notifications_channel.poll
+
+      notification = notifications.create(message: "A new koza's arrived", channel: 'system-notifications')
+
+      sleep 20
+
+      expect(poller.responses.size).to eq(1)
+      expect(JSON.parse(poller.responses.last.body)["payload"]["message"]).to eq("A new koza's arrived")
+
+      notification.message = "A koza's gone"
+      notification.save
+
+      sleep 20
+
+      expect(poller.responses.size).to eq(2)
+      expect(JSON.parse(poller.responses.last.body)["payload"]["message"]).to eq("A koza's gone")
+
+      poller.terminate
+    end
+  end
+
+  describe 'subscribing to a room' do
+    before(:each) { Celluloid.boot }
+
+    after(:each) { Celluloid.shutdown }
+
+    let!(:house) {
+      @instance.channels.create name: 'house', type: 'separate_rooms', other_permissions: 'publish', custom_publish: true
+    }
+    let!(:shout) {
+      @instance.classes.create name: 'shout', schema: [{name: 'message', type: 'string'}]
+    }
+
+    specify do
+      shout.objects.create channel: 'house', channel_room: 'bathroom', message: "Where's the water?"
+      shout.objects.create channel: 'house', channel_room: 'basement', message: "Where's the light?"
+
+      expect(house.history.all(room: 'bathroom').count).to eq(1)
+      expect(house.history.all(room: 'basement').count).to eq(1)
+      expect(house.history.all.count).to eq(2)
+    end
+  end
+
+  describe 'using syncano on behalf of the user' do
+    let(:user_api_key) { @instance.api_keys.create.api_key }
+    let(:user) {
+      @instance.users.create username: 'kiszonka', password: 'passwd'
+    }
+    let(:another_user) {
+      @instance.users.create username: 'another', password: 'user'
+    }
+    let(:user_instance) {
+      Syncano.connect(api_key: user_api_key, user_key: user.user_key).
+        instances.first
+    }
+    let(:another_user_instance) {
+      Syncano.connect(api_key: user_api_key, user_key: another_user.user_key).
+        instances.first
+    }
+    let(:group) { @instance.groups.create label: 'content creators' }
+
+    before do
+      group.users.create user: user.primary_key
+      group.users.create user: another_user.primary_key
+
+      @instance.classes.create name: 'book',
+                               schema: [{ name: 'title', type: 'string' }],
+                               group: group.primary_key,
+                               group_permissions: 'create_objects'
+    end
 
     specify do
-      expect { subject.create slug: 'web-wurst', codebox: codebox.primary_key }.to create_resource
+      owner_books = user_instance.classes.find('book').objects
+      book = owner_books.create(title: 'Oliver Twist', owner_permissions: 'write')
+
+      expect(owner_books.all.to_a).to_not be_empty
+
+      group_member_books = another_user_instance.classes.find('book').objects
+      expect(group_member_books.all.to_a).to be_empty
 
-      expect(subject.first.run['result']).to eq('currywurst')
+      book.group_permissions = 'read'
+      book.group = group.primary_key
+      book.save
 
-      expect { subject.first.destroy }.to destroy_resource
+      expect(group_member_books.all.to_a).to_not be_empty
     end
   end
 

data/spec/spec_helper.rb

@@ -7,6 +7,7 @@ Dotenv.load
 require 'rspec-prof' if ENV['SPEC_PROFILE']
 require 'syncano'
 require 'webmock/rspec'
+require 'celluloid/test'
 
 WebMock.disable_net_connect!
 
@@ -16,4 +17,5 @@ end
 
 def endpoint_uri(path)
   [Syncano::Connection.api_root,"v1", path].join("/")
-end
+end
+