magic-admin 0.0.0 → 0.1.0

data/lib/magic-admin/util.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module MagicAdmin
+
+  module Util
+
+    # Description:
+    #   Method provides you platform information hash
+    #
+    # Returns:
+    #   hash with following keys.
+    #       platform:
+    #       language:
+    #       language_version:
+    #       user_name:
+    def self.platform_info
+      {
+        platform: Config.platform,
+        language: Config.language,
+        language_version: Config.language_version,
+        user_name: Config.user_name
+      }
+    end
+
+    # Description:
+    #   Method provides you user agent hash
+    #
+    # Returns:
+    #   hash with following keys.
+    #       sdk_version:
+    #       publisher:
+    #       platform:
+    def self.user_agent
+      {
+        sdk_version: MagicAdmin::VERSION,
+        publisher: Config.publisher,
+        platform: platform_info
+      }
+    end
+
+    # Description:
+    #   Method provides you request headers hash
+    #
+    # Arguments:
+    #   secret_key: API Secret Key.
+    #
+    # Returns:
+    #   hash with following keys.
+    #       content-type:
+    #       X-Magic-Secret-Key:
+    #       User-Agent:
+    def self.headers(secret_key)
+      {
+        "content-type": "application/json",
+        "X-Magic-Secret-Key": secret_key,
+        "User-Agent": Util.user_agent
+      }
+    end
+
+  end
+end

data/lib/magic-admin/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module MagicAdmin
+  VERSION = "0.1.0"
+end

data/magic-admin.gemspec

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(::File.join(::File.dirname(__FILE__), "lib"))
+
+require "magic-admin/version"
+
+Gem::Specification.new do |s|
+  s.name = "magic-admin"
+  s.version = MagicAdmin::VERSION
+  s.required_ruby_version = ">= 2.5.0"
+  s.summary = "Ruby bindings for the Magic Admin API"
+
+  s.description = "The Magic Admin Ruby provides convenient ways " \
+                  "for developers to interact with Magic API endpoints" \
+                  "and an array of utilities to handle DID Token."
+  s.author = "Magic Labs Inc."
+  s.email = "support@magic.link"
+  s.homepage = "https://docs.magic.link/admin-sdk/ruby"
+  s.license = "MIT"
+
+  s.metadata = {
+  }
+
+  s.add_dependency "eth", "~> 0.4"
+  s.add_development_dependency "byebug", "~> 11.0"
+  s.add_development_dependency "rspec", "~> 3.9"
+  s.add_development_dependency "rubocop", "~> 0.80"
+  s.add_development_dependency "webmock", "~> 3.8"
+  s.add_development_dependency "simplecov", "~> 0.19"
+
+  s.files = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- test/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n")
+                                           .map { |f| ::File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/test/http/client_test.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe MagicAdmin::Http::Client do
+  let(:api_base) { MagicAdmin::Config.api_base }
+  let(:retries) { 3 }
+  let(:backoff) { 0.02 }
+  let(:timeout) { 5 }
+  let(:stub_response_body) do
+    { "data" => {}, "error_code" => "", "message" => "", "status" => "ok" }
+  end
+
+  subject { described_class.new(api_base, retries, timeout, backoff) }
+
+  it "present attr_reader" do
+    expect(subject).to respond_to(:retries)
+    expect(subject).to respond_to(:backoff)
+    expect(subject).to respond_to(:timeout)
+    expect(subject).to respond_to(:base_url)
+    expect(subject).to respond_to(:http_request)
+    expect(subject).to respond_to(:http_response)
+  end
+
+  context "#call" do
+    it "calling methods" do
+      stub_request(:get, "https://api.magic.link//v1/admin/auth/user/get")
+        .to_return(status: 200, body: stub_response_body.to_json, headers: {})
+      expect(subject).to receive(:backoff_retries)
+        .with(subject.retries, subject.backoff)
+      expect(subject.http_response).to receive(:from_net_http)
+
+      subject.call(:get, "/v1/admin/auth/user/get", {})
+    end
+  end
+
+  describe "private methods" do
+    context "#backoff_retries" do
+      describe "when raise StandardError error" do
+        it "retries until attempts >= max_retries" do
+          block = proc {}
+          max_retries = 3
+
+          expect(block).to receive(:call)
+            .and_raise(StandardError)
+            .exactly(max_retries)
+            .times
+
+          expect do
+            subject.send(:backoff_retries,
+                         max_retries,
+                         backoff,
+                         &block)
+          end .to raise_error(StandardError)
+        end
+      end
+    end
+
+    context "#use_ssl?" do
+      it "return true when url schema is https" do
+        url_with_scheme = double("url", scheme: "https")
+        expect(subject.send(:use_ssl?, url_with_scheme)).to be_truthy
+      end
+    end
+
+    context "#base_client" do
+      it "calling http request with arguments" do
+        url = double("url", scheme: "https", host: "localhost", port: 3000)
+        request = double("request")
+        read_timeout = double("read_timeout")
+
+        expect(Net::HTTP).to receive(:start)
+          .with(url.host, url.port, use_ssl: true)
+
+        subject.send(:base_client, url, request, read_timeout)
+      end
+    end
+  end
+end

data/test/http/request_test.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe MagicAdmin::Http::Request do
+  let(:url) { URI("https://api.magic.link/v1/admin/auth/user/get") }
+  let(:options) { {} }
+  describe "class methods" do
+    context ".request" do
+      it "raise error when method is not [GET POST]" do
+        expect do
+          described_class.request(:put,
+                                  url,
+                                  options)
+        end .to raise_error(MagicAdmin::APIError,
+                            "Request method not supported.")
+      end
+
+      it "when method is GET" do
+        expect_any_instance_of(described_class).to receive(:get)
+          .with(url, options)
+
+        described_class.request(:get, url, options)
+      end
+
+      it "when method is POST" do
+        expect_any_instance_of(described_class).to receive(:post)
+          .with(url, options)
+
+        described_class.request(:post, url, options)
+      end
+    end
+  end
+
+  context "#get" do
+    it "return response" do
+      expect(subject.get(url, options)).to be_instance_of(Net::HTTP::Get)
+
+      expected = "https://api.magic.link/v1/admin/auth/user/get?"
+      expect(subject.get(url, options).uri.to_s).to eq(expected)
+    end
+  end
+
+  context "#post" do
+    it "return response" do
+      expect(subject.post(url, options)).to be_instance_of(Net::HTTP::Post)
+
+      expected = "https://api.magic.link/v1/admin/auth/user/get"
+      expect(subject.post(url, options).uri.to_s).to eq(expected)
+    end
+  end
+end

data/test/http/response_test.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe MagicAdmin::Http::Response do
+  let(:stub_response_body) do
+    { "data" => {}, "error_code" => "", "message" => "", "status" => "ok" }
+  end
+
+  let(:http_resp) do
+    double(
+      "http_resp",
+      body: stub_response_body.to_json,
+      code: 200,
+      message: "ok"
+    )
+  end
+
+  let(:url) { URI("https://api.magic.link//v1/admin/auth/user/get") }
+  let(:request) { MagicAdmin::Http::Request.request(:get, url, {}) }
+
+  subject { described_class.new(http_resp) }
+
+  it "present attr_reader" do
+    expect(subject).to respond_to(:data)
+    expect(subject).to respond_to(:content)
+    expect(subject).to respond_to(:status_code)
+  end
+
+  context "#error_opt" do
+    it "return response" do
+      expect(subject.error_opt(request)).to include(
+        :http_status,
+        :http_code,
+        :http_response,
+        :http_message,
+        :http_error_code,
+        :http_request_params,
+        :http_method
+      )
+    end
+  end
+
+  describe "class_methods" do
+    context ".from_net_http" do
+      it "with valid request" do
+        reps = described_class.from_net_http(http_resp, request)
+        expect(reps).to be_instance_of(MagicAdmin::Http::Response)
+
+        expect(reps.status_code).to eq(200)
+      end
+
+      context "with invalid request" do
+        it "raise error BadRequestError" do
+          error_resp = instance_double(
+            Net::HTTPBadRequest,
+            body: stub_response_body.to_json,
+            code: 400,
+            message: "HTTP Bad Request"
+          )
+
+          allow(Net::HTTPBadRequest).to receive(:===)
+            .with(error_resp)
+            .and_return(true)
+
+          expect do
+            described_class.from_net_http(error_resp, request)
+          end .to raise_error(MagicAdmin::BadRequestError)
+        end
+
+        it "raise error HTTPUnauthorized" do
+          error_resp = instance_double(
+            Net::HTTPUnauthorized,
+            body: stub_response_body.to_json,
+            code: 401,
+            message: "HTTP Unauthorized  Request Error"
+          )
+
+          allow(Net::HTTPUnauthorized).to receive(:===)
+            .with(error_resp)
+            .and_return(true)
+
+          expect do
+            described_class.from_net_http(error_resp, request)
+          end .to raise_error(MagicAdmin::AuthenticationError)
+        end
+
+        it "raise error HTTPForbidden" do
+          error_resp = instance_double(
+            Net::HTTPForbidden,
+            body: stub_response_body.to_json,
+            code: 403,
+            message: "HTTP Forbidden Request Error"
+          )
+
+          allow(Net::HTTPForbidden).to receive(:===)
+            .with(error_resp)
+            .and_return(true)
+
+          expect do
+            described_class.from_net_http(error_resp, request)
+          end .to raise_error(MagicAdmin::ForbiddenError)
+        end
+
+        it "raise error HTTPTooManyRequests" do
+          error_resp = instance_double(
+            Net::HTTPTooManyRequests,
+            body: stub_response_body.to_json,
+            code: 429,
+            message: "HTTP Many Request Error"
+          )
+
+          allow(Net::HTTPTooManyRequests).to receive(:===)
+            .with(error_resp)
+            .and_return(true)
+
+          expect do
+            described_class.from_net_http(error_resp, request)
+          end .to raise_error(MagicAdmin::RateLimitingError)
+        end
+
+        it "raise error HTTPServerError" do
+          error_resp = instance_double(
+            Net::HTTPServerError,
+            body: stub_response_body.to_json,
+            code: 500,
+            message: "HTTP Internal Server Error"
+          )
+
+          allow(Net::HTTPServerError).to receive(:===)
+            .with(error_resp)
+            .and_return(true)
+
+          expect do
+            described_class.from_net_http(error_resp, request)
+          end .to raise_error(MagicAdmin::APIError)
+        end
+
+        it "raise error HTTPGatewayTimeout" do
+          error_resp = instance_double(
+            Net::HTTPGatewayTimeout,
+            body: stub_response_body.to_json,
+            code: 504,
+            message: "HTTP Gateway Timeoutr"
+          )
+
+          allow(Net::HTTPGatewayTimeout).to receive(:===)
+            .with(error_resp)
+            .and_return(true)
+
+          expect do
+            described_class.from_net_http(error_resp, request)
+          end .to raise_error(MagicAdmin::APIError)
+        end
+
+        it "raise error HTTPServiceUnavailable" do
+          error_resp = instance_double(
+            Net::HTTPServiceUnavailable,
+            body: stub_response_body.to_json,
+            code: 503,
+            message: "HTTP Service Unavailable"
+          )
+
+          allow(Net::HTTPServiceUnavailable).to receive(:===)
+            .with(error_resp)
+            .and_return(true)
+
+          expect do
+            described_class.from_net_http(error_resp, request)
+          end .to raise_error(MagicAdmin::APIError)
+        end
+
+        it "raise error HTTPBadGateway" do
+          error_resp = instance_double(
+            Net::HTTPBadGateway,
+            body: stub_response_body.to_json,
+            code: 502,
+            message: "HTTP Bad Gateway"
+          )
+
+          allow(Net::HTTPBadGateway).to receive(:===)
+            .with(error_resp)
+            .and_return(true)
+
+          expect do
+            described_class.from_net_http(error_resp, request)
+          end .to raise_error(MagicAdmin::APIError)
+        end
+      end
+    end
+  end
+end

data/test/magic_test.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Magic do
+  let(:env_secret_key) { "<ENV_MAGIC_API_SECRET_KEY>" }
+  let(:agr_secret_key) { "<ARG_MAGIC_API_SECRET_KEY>" }
+
+  describe "magic object without arguments and environment variables" do
+    it "should raise an error" do
+      expect { Magic.new }.to raise_exception MagicAdmin::MagicError
+    end
+  end
+
+  describe "magic object set secret_key" do
+    it "should be set with environment variable" do
+      ENV["MAGIC_API_SECRET_KEY"] = env_secret_key
+      magic = Magic.new
+      expect(magic.secret_key).to eq(env_secret_key)
+    end
+
+    it "should be set with arguments" do
+      magic = Magic.new(api_secret_key: agr_secret_key)
+      expect(magic.secret_key).to eq(agr_secret_key)
+    end
+
+    it "should be set with arguments ignore environment variable" do
+      ENV["MAGIC_API_SECRET_KEY"] = env_secret_key
+      magic = Magic.new(api_secret_key: agr_secret_key)
+      expect(magic.secret_key).to eq(agr_secret_key)
+      expect(magic.secret_key).not_to eq(env_secret_key)
+    end
+  end
+
+  describe "magic object network strategy" do
+    before(:each) do
+      ENV["MAGIC_API_SECRET_KEY"] = spec_api_secret_key
+    end
+
+    describe "set retries" do
+      let(:default_retries) { 3 }
+      let(:env_retries) { "4" }
+      let(:arg_retries) { 5 }
+
+      it "should be set with default values" do
+        http_client = Magic.new.http_client
+        expect(http_client.retries).to eq(default_retries)
+      end
+
+      it "should be set with environment variable" do
+        ENV["MAGIC_API_RETRIES"] = env_retries
+        http_client = Magic.new.http_client
+        expect(http_client.retries).to eq(env_retries.to_f)
+      end
+
+      it "should be set with argument" do
+        http_client = Magic.new(retries: arg_retries).http_client
+        expect(http_client.retries).to eq(arg_retries)
+      end
+
+      it "should be set with argument ignore environment variable" do
+        ENV["MAGIC_API_RETRIES"] = env_retries
+        http_client = Magic.new(retries: arg_retries).http_client
+        expect(http_client.retries).to eq(arg_retries)
+      end
+    end
+
+    describe "set timeout" do
+      let(:default_timeout) { 5 }
+      let(:env_timeout) { "6" }
+      let(:arg_timeout) { 7 }
+
+      it "should be set with default values" do
+        http_client = Magic.new.http_client
+        expect(http_client.timeout).to eq(default_timeout)
+      end
+
+      it "should be set with environment variable" do
+        ENV["MAGIC_API_TIMEOUT"] = env_timeout
+        http_client = Magic.new.http_client
+        expect(http_client.timeout).to eq(env_timeout.to_f)
+      end
+
+      it "should be set with argument" do
+        http_client = Magic.new(timeout: arg_timeout).http_client
+        expect(http_client.timeout).to eq(arg_timeout)
+      end
+
+      it "should be set with argument ignore environment variable" do
+        ENV["MAGIC_API_TIMEOUT"] = env_timeout
+        http_client = Magic.new(timeout: arg_timeout).http_client
+        expect(http_client.timeout).to eq(arg_timeout)
+      end
+    end
+
+    describe "set backoff" do
+      let(:default_backoff) { 0.02 }
+      let(:env_backoff) { "0.03" }
+      let(:arg_backoff) { 0.04 }
+
+      it "should be set with default values" do
+        http_client = Magic.new.http_client
+        expect(http_client.backoff).to eq(default_backoff)
+      end
+
+      it "should be set with environment variable" do
+        ENV["MAGIC_API_BACKOFF"] = env_backoff
+        http_client = Magic.new.http_client
+        expect(http_client.backoff).to eq(env_backoff.to_f)
+      end
+
+      it "should be set with argument" do
+        http_client = Magic.new(backoff: arg_backoff).http_client
+        expect(http_client.backoff).to eq(arg_backoff)
+      end
+
+      it "should be set with argument ignore environment variable" do
+        ENV["MAGIC_API_BACKOFF"] = env_backoff
+        http_client = Magic.new(backoff: arg_backoff).http_client
+        expect(http_client.backoff).to eq(arg_backoff)
+      end
+    end
+  end
+end