ribose 0.3.1 → 0.5.0

data/spec/ribose/client_spec.rb

@@ -7,42 +7,41 @@ RSpec.describe Ribose::Client do
         client = Ribose::Client.new
 
         expect(client.api_token).to eq(Ribose.configuration.api_token)
-        expect(client.user_email).to eq(Ribose.configuration.user_email)
+        expect(client.api_email).to eq(Ribose.configuration.api_email)
       end
     end
 
     context "custom attribtues provided" do
       it "initialize with the supplied attribtues" do
-        client = Ribose::Client.new(token: 123, email: "john@ex.com")
+        email = "john@ex.com"
+        token = "SECRET_API_TOKEN"
+        client = Ribose::Client.new(api_token: token, api_email: email)
 
-        expect(client.api_token).to eq("123")
-        expect(client.user_email).to eq("john@ex.com")
+        expect(client.api_token).to eq(token)
+        expect(client.api_email).to eq(email)
       end
     end
   end
 
   describe ".from_login" do
     it "authenticate the user and build a client" do
-      email = "useremail@example..com"
-      password = "supersecretpassword"
+      email = "user.email@gmail.com"
+      password = "supser.secrect.password"
 
-      allow(Ribose::Session).to receive(:create).and_return(session_hash)
+      allow(Ribose::Session).to receive(:create).and_return(session)
       client = Ribose::Client.from_login(email: email, password: password)
 
-      expect(client.user_email).to eq(email)
-      expect(client.api_token).to eq(session_hash["authentication_token"])
+      expect(client.api_email).to eq(email)
+      expect(client.uid).to eq(session.uid)
+      expect(client.client_id).to eq(session.client)
     end
   end
 
-  def session_hash
-    {
-      "authentication_token" => "SecretToken",
-      "last_activity" => {
-        "id" => 122072207,
-        "session_id" => "SessionId",
-        "browser" => "Ribose Ruby Client",
-        "user_id" => "user-uuid-123-4567"
-      },
-    }
+  def session
+    @session ||= Ribose::SessionData.new(
+      uid: "hello",
+      expiry: Time.now + 3600,
+      client: "RIBOSE_RUBY_CLIENT",
+    )
   end
 end

data/spec/ribose/config_spec.rb

@@ -20,7 +20,6 @@ RSpec.describe Ribose::Config do
       expect(Ribose.configuration.debug_mode?).to be_falsey
       expect(Ribose.configuration.api_token).to eq(api_token)
       expect(Ribose.configuration.user_email).to eq(user_email)
-      expect(Ribose.configuration.web_url).to eq ["https", api_host].join("://")
     end
   end
 

data/spec/ribose/connection_spec.rb

@@ -23,4 +23,15 @@ RSpec.describe Ribose::Connection do
       expect(suggestions.first.name).to eq("Jennie Doe")
     end
   end
+
+  describe ".disconnect" do
+    it "disconnect with provided connection" do
+      connection_id = 123_456
+      stub_ribose_connection_delete_api(connection_id)
+
+      expect do
+        Ribose::Connection.disconnect(connection_id)
+      end.not_to raise_error
+    end
+  end
 end

data/spec/ribose/file_uploader_spec.rb

@@ -7,18 +7,31 @@ RSpec.describe Ribose::FileUploader do
         space_id = 123_456_789
 
         stub_ribose_space_file_upload_api(space_id, file_attributes)
-        file_upload = Ribose::FileUploader.upload(space_id, file_attributes)
+        file_upload = Ribose::FileUploader.upload(space_id, **file_attributes)
 
         expect(file_upload.attachment.id).not_to be_nil
         expect(file_upload.attachment.author).to eq("John Doe")
         expect(file_upload.attachment.content_type).to eq("image/png")
       end
     end
+
+    context "with unknown file type" do
+      it "creates a new upload as octet-stream" do
+        space_id = 123_456_789
+        attributes = file_attributes(File.join(Ribose.root, "Rakefile"))
+
+        stub_ribose_space_file_upload_api(space_id, attributes)
+        file_upload = Ribose::FileUploader.upload(space_id, **attributes)
+
+        expect(file_upload.attachment.id).not_to be_nil
+        expect(file_upload.attachment.author).to eq("John Doe")
+      end
+    end
   end
 
-  def file_attributes
+  def file_attributes(file = nil)
     {
-      file: sample_fixture_file,
+      file: file || sample_fixture_file,
       tag_list: "sample, file, samplefile",
       description: "This is a sample file",
     }

data/spec/ribose/file_version_spec.rb

@@ -17,4 +17,60 @@ RSpec.describe Ribose::FileVersion do
       expect(file_version.current_version_id).to eq(789012)
     end
   end
+
+  describe ".download" do
+    context "with version id specified" do
+      it "downloads the specific file version" do
+        file_id = 123_456
+        space_id = 456_789
+        version_id = 789_012
+
+        output_file = "./tmp/download"
+        content = "This is the content in the file"
+
+        stub_aws_file_version_download_api(content)
+        buffer = stub_file_write_to_io(output_file)
+        stub_ribose_file_version_download_api(space_id, file_id, version_id)
+
+        Ribose::FileVersion.download(
+          space_id, file_id, version_id: version_id, output: output_file
+        )
+
+        expect(buffer).to eq(content)
+      end
+    end
+  end
+
+  describe ".create" do
+    it "create a new file version" do
+      file_id = 123_456
+      space_id = 456_789
+
+      stub_ribose_space_file_upload_api(space_id, file_attributes, file_id)
+      file = Ribose::FileVersion.create(space_id, file_id, **file_attributes)
+
+      expect(file.id).not_to be_nil
+      expect(file.author).to eq("John Doe")
+      expect(file.content_type).to eq("image/png")
+    end
+  end
+
+  def file_attributes
+    {
+      file: sample_fixture_file,
+      description: "Version 2.0",
+      tag_list: "tags for new version",
+    }
+  end
+
+  def sample_fixture_file
+    @sample_fixture_file ||= File.join(Ribose.root, "spec/fixtures/sample.png")
+  end
+
+  def stub_file_write_to_io(output_file)
+    buffer = StringIO.new
+    allow(File).to receive(:open).with(output_file, "w").and_yield(buffer)
+
+    buffer.string
+  end
 end

data/spec/ribose/message_spec.rb

@@ -20,9 +20,10 @@ RSpec.describe Ribose::Message do
   describe ".create" do
     it "creates a new message into a conversation" do
       space_id = 123_456
+      message_attributes = message_attrs.merge(space_id: space_id)
 
       stub_ribose_message_create(space_id, message: message_attrs)
-      message = Ribose::Message.create(message_attrs.merge(space_id: space_id))
+      message = Ribose::Message.create(**message_attributes)
 
       expect(message.id).not_to be_nil
       expect(message.user.name).to eq("John Doe")
@@ -37,7 +38,7 @@ RSpec.describe Ribose::Message do
 
       stub_ribose_message_update(space_id, message_id, message: message_attrs)
       message = Ribose::Message.update(
-        message_attrs.merge(space_id: space_id, message_id: message_id),
+        **message_attrs.merge(space_id: space_id, message_id: message_id),
       )
 
       expect(message.user.name).to eq("John Doe")

data/spec/ribose/session_spec.rb

@@ -6,41 +6,35 @@ RSpec.describe Ribose::Session do
       username = "super.user"
       password = "supper.secreet.password"
 
-      stub_session_creation_request_via_web
+      stub_post_signin_request
       session = Ribose::Session.create(username: username, password: password)
 
-      expect(session["created_at"]).not_to be_nil
-      expect(session["authentication_token"]).to eq("user-super-secret-token")
+      expect(session.uid).to eq(session_headers["uid"])
+      expect(session.client).to eq(session_headers["client"])
+      expect(session["access-token"]).to eq(session_headers["access-token"])
     end
   end
 
-  def login_url
-    ribose_url_for("login")
-  end
-
-  def ribose_url_for(*endpoints)
-    [Ribose.configuration.web_url, *endpoints].join("/")
+  def session_headers
+    @session_headers ||= {
+      "uid" => "user@example.com",
+      "expiry" => Time.now,
+      "client" => "sample-user-client",
+      "access-token" => "super.secret.access.token",
+    }
   end
 
-  def stub_session_creation_request_via_web
-    stub_get_request_with_login_page
-    stub_post_request_with_empty_body
-    stub_general_inforomation_request
-  end
-
-  def stub_get_request_with_login_page
-    stub_request(:get, login_url).and_return(
-      body: ribose_fixture("login", "html"),
-      headers: { content_type: "text/html" },
+  def stub_post_signin_request
+    stub_request(:post, login_url).and_return(
+      body: ribose_fixture("empty"), headers: session_headers,
     )
   end
 
-  def stub_general_inforomation_request
-    stub_request(:get, ribose_url_for(["settings", "general", "info"])).
-      and_return(body: ribose_fixture("general_information"), status: 200)
+  def login_url
+    [api_host, "api/v2/auth/sign_in"].join("/")
   end
 
-  def stub_post_request_with_empty_body
-    stub_request(:post, login_url).and_return(body: ribose_fixture("empty"))
+  def api_host
+    "https://#{Ribose.configuration.api_host}"
   end
 end

data/spec/ribose/space_file_spec.rb

@@ -28,12 +28,43 @@ RSpec.describe Ribose::SpaceFile do
     end
   end
 
+  describe ".download" do
+    context "without specific version id" do
+      it "fetch version id and then downloads the file" do
+        file_id = 123_456_789
+        space_id = 456_789_012
+
+        allow(Ribose::FileVersion).to receive(:download)
+        stub_ribose_space_file_fetch_api(space_id, file_id)
+
+        Ribose::SpaceFile.download(space_id, file_id)
+
+        expect(Ribose::FileVersion).to have_received(:download).
+          with(space_id, file_id, version_id: 11559)
+      end
+    end
+
+    context "with specific version id" do
+      it "sends downlod message to the downloader" do
+        file_id = 123_456_789
+        space_id = 456_789_012
+        version_id = 123_456_789
+
+        allow(Ribose::FileVersion).to receive(:download)
+        Ribose::SpaceFile.download(space_id, file_id, version_id: version_id)
+
+        expect(Ribose::FileVersion).to have_received(:download).
+          with(space_id, file_id, version_id: version_id)
+      end
+    end
+  end
+
   describe ".create" do
     it "creates a new file with provided details" do
       space_id = 123_456_789
 
       stub_ribose_space_file_upload_api(space_id, file_attributes)
-      file = Ribose::SpaceFile.create(space_id, file_attributes)
+      file = Ribose::SpaceFile.create(space_id, **file_attributes)
 
       expect(file.id).not_to be_nil
       expect(file.author).to eq("John Doe")

data/spec/ribose/space_spec.rb

@@ -28,7 +28,7 @@ RSpec.describe Ribose::Space do
   describe ".create" do
     it "creates a new space with provided details" do
       stub_ribose_space_create_api(space_attributes)
-      space = Ribose::Space.create(space_attributes)
+      space = Ribose::Space.create(**space_attributes)
 
       expect(space.id).not_to be_nil
       expect(space.visibility).to eq("invisible")
@@ -59,6 +59,17 @@ RSpec.describe Ribose::Space do
     end
   end
 
+  describe ".delete" do
+    it "deletes an existing space" do
+      space_id = 123_456_789
+      stub_ribose_space_remove_api(space_id, password_confirmation: 1234)
+
+      expect do
+        Ribose::Space.delete(space_id, confirmation: 1234)
+      end.not_to raise_error
+    end
+  end
+
   def space_attributes
     {
       access: "private",

data/spec/ribose/user_spec.rb

@@ -18,7 +18,7 @@ RSpec.describe Ribose::User do
   describe ".activate" do
     it "complete the user signup process" do
       stub_ribose_app_user_activate_api(user_attributes)
-      user = Ribose::User.activate(user_attributes)
+      user = Ribose::User.activate(**user_attributes)
 
       expect(user.id).not_to be_nil
       expect(user.name).to eq("John Doe")
@@ -30,7 +30,7 @@ RSpec.describe Ribose::User do
     @user_attributes ||= {
       email: "john.doe@example.com",
       password: "SecurePassword",
-      otp: "OTP_RECEIVED_VIA_EMAIL",
+      edata: "OTP_RECEIVED_VIA_EMAIL",
     }
   end
 

data/spec/spec_helper.rb

@@ -15,8 +15,9 @@ RSpec.configure do |config|
 
   config.before :all do
     Ribose.configure do |ribose_config|
-      ribose_config.api_token = ENV["RIBOSE_API_TOKEN"] || "RIBOSE_API_TOKEN"
       ribose_config.user_email = ENV["RIBOSE_USER_EMAIL"] || "RIBOSE_USER_EMAIL"
+      ribose_config.user_password = ENV["RIBOSE_USER_PASSWORD"] || "SECRET_PASS"
+      ribose_config.client = Ribose::Client.new
     end
   end
 end

data/spec/support/fake_ribose_api.rb

@@ -30,6 +30,12 @@ module Ribose
       )
     end
 
+    def stub_ribose_space_delete_api(space_id, options = {})
+      stub_api_response(
+        :delete, "spaces/#{space_id}", data: options, filename: "empty"
+      )
+    end
+
     def stub_ribose_feed_api
       stub_api_response(:get, "feeds", filename: "feeds")
     end
@@ -173,7 +179,7 @@ module Ribose
     def stub_ribose_app_user_activate_api(attributes)
       stub_api_response(
         :post,
-        "signup.user",
+        "api/v2/auth",
         data: { user: attributes },
         filename: "user_activated",
       )
@@ -220,6 +226,17 @@ module Ribose
       )
     end
 
+    def stub_ribose_file_version_download_api(sid, fid, vid)
+      version = ["spaces", sid, "file/files", fid, "versions", vid].join("/")
+      stub_request(:get, ribose_endpoint(version)).to_return(
+        headers: { location: "https://ribose-data.aws.com", status: 302 },
+      )
+    end
+
+    def stub_aws_file_version_download_api(content)
+      stub_request(:get, "https://ribose-data.aws.com").to_return(body: content)
+    end
+
     def stub_ribose_space_conversation_list(space_id)
       stub_api_response(
         :get, conversations_path(space_id), filename: "conversations"
@@ -310,6 +327,12 @@ module Ribose
       stub_api_response(:get, "people/connections?s=", filename: "connections")
     end
 
+    def stub_ribose_connection_delete_api(id)
+      stub_api_response(
+        :delete, ["people", "connections", id].join("/"), filename: "empty"
+      )
+    end
+
     def stub_ribose_suggestion_list_api
       stub_api_response(
         :get, "people_finding", filename: "connection_suggestion"
@@ -526,16 +549,16 @@ module Ribose
 
         if Ribose.configuration.api_token
           headers["X-Indigo-Token"] = client.api_token
-          headers["X-Indigo-Email"] = client.user_email
+          headers["X-Indigo-Email"] = client.api_email
         end
       end
     end
 
-    def response_with(filename:, status:)
+    def response_with(filename:, status:, content_type: "application/json")
       {
         status: status,
         body: ribose_fixture(filename),
-        headers: { content_type: "application/json" },
+        headers: { content_type: content_type },
       }
     end
 
@@ -546,11 +569,15 @@ module Ribose
       File.read(File.expand_path(file_path, __FILE__))
     end
 
-    def stub_api_response(method, endpoint, filename:,
-                          status: 200, data: nil, client: nil)
+    def stub_api_response(method, endpoint, filename:, status: 200, data: nil,
+                          client: nil, content_type: "application/json")
       stub_request(method, ribose_endpoint(endpoint)).
         with(ribose_headers(data: data, client: client)).
-        to_return(response_with(filename: filename, status: status))
+        to_return(
+          response_with(
+            filename: filename, status: status, content_type: content_type,
+          ),
+        )
     end
   end
 end

data/spec/support/file_upload_stub.rb

@@ -2,16 +2,16 @@ require "faraday"
 
 module Ribose
   module FileUploadStub
-    def stub_ribose_space_file_upload_api(space_id, attributes)
+    def stub_ribose_space_file_upload_api(space_id, attributes, file_id = nil)
       stub_ribose_aws_s3_file_upload_api
-      stub_ribose_file_prepare_api(space_id, attributes)
-      stub_ribose_file_upload_notify_api(space_id, attributes)
+      stub_ribose_file_prepare_api(space_id, attributes, file_id)
+      stub_ribose_file_upload_notify_api(space_id, attributes, file_id)
     end
 
-    def stub_ribose_file_prepare_api(space_id, attributes)
+    def stub_ribose_file_prepare_api(space_id, attributes, file_id = nil)
       stub_api_response(
         :get,
-        ribose_prepare_endpoint(space_id, attributes),
+        ribose_prepare_endpoint(space_id, attributes, file_id),
         filename: "file_upload_prepared",
       )
     end
@@ -22,23 +22,26 @@ module Ribose
         to_return(response_with(filename: "empty", status: 200))
     end
 
-    def stub_ribose_file_upload_notify_api(space_id, attributes)
+    def stub_ribose_file_upload_notify_api(space_id, attributes, file_id = nil)
       stub_api_response(
         :post,
-        ribose_file_endpoint(space_id),
-        data: build_notify_request_body(attributes),
+        ribose_file_endpoint(space_id, file_id),
+        data: build_notify_request_body(attributes, file_id),
         filename: "file_uploaded",
+        content_type: "text/html",
       )
     end
 
     private
 
-    def ribose_file_endpoint(space_id)
-      ["spaces", space_id, "file", "files"].join("/")
+    def ribose_file_endpoint(space_id, file_id = nil)
+      end_path = file_id ? "#{file_id}/versions" : nil
+      ["spaces", space_id, "file", "files", end_path].compact.join("/")
     end
 
-    def ribose_prepare_endpoint(sid, attrs)
-      [ribose_file_endpoint(sid), "prepare?#{prepare_params(attrs)}"].join("/")
+    def ribose_prepare_endpoint(sid, attrs, file_id = nil)
+      [ribose_file_endpoint(sid, file_id), "prepare?#{prepare_params(attrs)}"].
+        join("/")
     end
 
     def prepare_params(attributes)
@@ -49,16 +52,19 @@ module Ribose
       )
     end
 
-    def build_notify_request_body(attributes)
+    def build_notify_request_body(attributes, file_id = nil)
+      file_info_key = file_id ? "file_info_version" : "file_info"
+
       extract_file_details(attributes).merge(
-        file_info: extract_file_info(attributes),
+        file_info_key.to_sym => extract_file_info(attributes),
         key: "uploads/123456789/${filename}",
       )
     end
 
     def content_type_form_file(file)
       require "mime/types"
-      MIME::Types.type_for(file).first.content_type
+      mime = MIME::Types.type_for(file).first
+      mime ? mime.content_type : "application/octet-stream"
     end
 
     def extract_file_details(attributes)