naranya_ecm-sdk 0.0.42 → 0.0.43

data/lib/ncontent/sdk/rest_client.rb

@@ -0,0 +1,131 @@
+require 'oauth2'
+require 'ncontent/sdk/faraday_middleware'
+
+module NContent
+
+  module SDK
+
+    class RESTClient
+
+      CLIENT_TOKEN_CACHE_KEY = "ncontent/api_client/client_token".freeze
+
+      class << self
+        delegate :config, :logger, :cache, to: NContent::SDK
+      end
+
+      # Returns the thread's OAuth2 client instance.
+      #
+      # In multi-thread environments, each thread will have it's own client
+      # instance object - since it's saved as a @instance_variable - but
+      # shouldn't be a problem since the mutable data is actually the
+      # client_token (see self.client_token).
+      def self.instance
+        @instance ||= OAuth2::Client.new(
+          config.api_key, config.api_secret, site: config.api_host
+        ) do |faraday|
+          ### Oauth2 Client (Faraday) builder:
+
+          faraday.request :url_encoded # them posts...
+
+          faraday.response :logger, logger
+
+          faraday.use NContent::SDK::FaradayMiddleware::RESTAPICallBenchmark
+
+          faraday.use NContent::SDK::FaradayMiddleware::ResponseParser
+
+          if defined?(Patron)
+            faraday.adapter :patron # Prefer patron if exists
+          else
+            faraday.adapter Faraday.default_adapter  # make requests with Net::HTTP
+          end
+        end
+      end
+
+      # Returns a client_token initialized from cache.
+      #
+      # In multi-thread environments, each thread will have it's own
+      # client_token object - since it's saved as a @instance_variable -, but
+      # all of them should have the same token data - since it's initialized
+      # from cache (We're assuming a thread-safe cache such as redis gem).
+      def self.client_token
+        @client_token ||= begin
+          cached_token_data = cache.read CLIENT_TOKEN_CACHE_KEY
+          if cached_token_data.present?
+            OAuth2::AccessToken.from_hash instance, cached_token_data
+          else
+            new_token = instance.client_credentials.get_token
+            cache.write CLIENT_TOKEN_CACHE_KEY, new_token.to_hash
+            new_token
+          end
+        end
+      end
+
+      # Clears the thread's token object. If called with 'true', it also
+      # clears the token data from the cache.
+      def self.clear_client_token!(clear_from_cache = false)
+        cache.delete CLIENT_TOKEN_CACHE_KEY if clear_from_cache
+        @client_token = nil
+        true
+      end
+
+      # Make a request to the API:
+      #
+      # @param [Symbol] verb the HTTP request method
+      # @param [String] path the HTTP URL path of the request
+      # @param [Hash] opts the options to make the request with
+      def self.request(verb, path=nil, opts = {}, &block)
+
+        cleared_cached_token_data = false
+
+        begin
+
+          # If we beforehand know that the current token expired then clear the
+          # token object from the current thread. We'll not clear it from the
+          # cache store here, as maybe another thread has already updated the
+          # cached token data:
+          clear_client_token! if client_token.expired?
+
+          client_token.request(verb, path, opts) do |req|
+            req.options.timeout = config.api_call_timeout
+            req.options.open_timeout = config.api_call_open_timeout
+            yield req if block_given?
+          end
+
+        rescue OAuth2::Error => error
+
+          if error.response.status == 401 && !cleared_cached_token_data
+            # Here the cached token data is stale, so we'll force the cached
+            # token data to be cleared:
+            cleared_cached_token_data = clear_client_token!(true)
+            retry
+          else
+            ::NaranyaEcm::Rest::RestError.raise_by_failed_response(error.response)
+          end
+        end
+      end
+
+      def self.get(path=nil, opts = {}, &block)
+        request(:get, path, opts, &block)
+      end
+
+      def self.post(path=nil, opts = {}, &block)
+        request(:post, path, opts, &block)
+      end
+
+      def self.put(path=nil, opts = {}, &block)
+        request(:put, path, opts, &block)
+      end
+
+      def self.patch(path=nil, opts = {}, &block)
+        request(:patch, path, opts, &block)
+      end
+
+      def self.delete(path=nil, opts = {}, &block)
+        request(:delete, path, opts, &block)
+      end
+
+    end
+
+  end
+
+end

data/lib/ncontent/sdk/testing/server_mock.rb

@@ -0,0 +1,316 @@
+require 'sinatra/base'
+require 'bson'
+
+module NContent
+  module SDK
+    module Testing
+
+      ##
+      # Clase que simula el servicio de nContent:
+      # Ver https://robots.thoughtbot.com/how-to-stub-external-services-in-tests
+      class ServerMock < Sinatra::Base
+
+        class ValidationError < StandardError
+          attr_reader :errors
+          def initialize(errors = {})
+            @errors = errors.collect({}) do |hsh, keyval|
+              key, val = keyval
+              hsh[key] = [] unless hsh[key].is_a? Array
+              hsh[key] << val
+              hsh
+            end
+          end
+        end
+
+        delegate :config, to: :class
+
+        class << self
+          delegate :config, to: NContent::SDK
+        end
+
+        COLLECTION_NAMES = %w(
+          categories content_versions contents download_authorizations
+          media_processes media_profiles media_resources
+        ).freeze
+
+        RESOURCE_TYPES = COLLECTION_NAMES.map(&:singularize).freeze
+
+        def self.get_blank_collection_set
+          COLLECTION_NAMES.inject({}) do |hash, collection_name|
+            hash[collection_name] = {}
+            hash
+          end.with_indifferent_access
+        end
+
+        def self.clear_collections!
+          @collections = nil
+        end
+
+        def self.collections
+          @collections ||= get_blank_collection_set
+        end
+
+        def self.method_missing(method_name, *args, &block)
+          if COLLECTION_NAMES.include? method_name.to_s
+
+            # Create the method:
+            define_singleton_method method_name do
+              collections[method_name.to_s]
+            end
+
+            # Call the newly defined method:
+            self.send method_name, *args
+          elsif method_name =~ /\Aget_(\w+)\z/ && RESOURCE_TYPES.include?($1)
+
+            # Create the method:
+            define_singleton_method method_name do |resource_id|
+              get_resource $1, resource_id
+            end
+
+            # Call the newly defined method:
+            self.send method_name, *args
+          elsif method_name =~ /\A(create|update|upsert)_(\w+)\z/ && RESOURCE_TYPES.include?($2)
+
+            # Create the methods:
+            %w(create update upsert).each do |method_prefix|
+              new_method_name = "#{method_prefix}_#{$2}".to_sym
+              define_singleton_method new_method_name do |*args|
+                upsert_resource $2.pluralize, *args
+              end
+            end
+
+            # Call the newly defined method:
+            self.send method_name, *args
+          else
+            super # You *must* call super if you don't handle the
+                  # method, otherwise you'll mess up Ruby's method
+                  # lookup.
+          end
+        end
+
+        def self.upsert_resource(collection_name, given_resource_attributes, resource_id = nil)
+          # Ignore the ID:
+          given_resource_attributes.delete 'id'
+
+          invalid_attributes = given_resource_attributes.select do |k, v|
+            v =~ /invalid/i
+          end
+
+          raise ValidationError, invalid_attributes.collect {} do |h, kv|
+            k, v = kv;
+            h[k] = ['is invalid']
+            h
+          end if invalid_attributes.any?
+
+          if resource_id.present? && collections[collection_name].key?(resource_id)
+            collections[collection_name][resource_id].merge! given_resource_attributes
+          else
+            # Caso especial:
+            if collection_name == 'contents'
+              given_resource_attributes.reverse_merge "lifecycle_state" => 'draft'
+
+              # Generar iconos y screenshots en caso de que sea Game:
+              if given_resource_attributes['type'] == "Game"
+                icon = self.upsert_media_resource(
+                  roles: ["icon"],
+                  downloadable_url: "http://test-bucket.s3.amazonaws.com/icons/original/#{resource_id}.jpg",
+                  type: "image/jpg",
+                  access_type: "public",
+                  parent_document_id: resource_id,
+                  parent_document_type: "Content"
+                )
+
+                %w(120w 150w 300w).each do |processed_role|
+                  self.upsert_media_resource(
+                    roles: ["icon", "processed", "v2", processed_role],
+                    downloadable_url: "http://test-bucket.s3.amazonaws.com/icons/#{processed_role}/#{resource_id}.jpg",
+                    type: "image/jpg",
+                    access_type: "public",
+                    parent_document_id: icon[:id],
+                    parent_document_type: "MediaResource"
+                  )
+                end
+
+              end
+            end
+
+            resource_id = (BSON::ObjectId.new).to_s
+            collections[collection_name][resource_id] = { id: resource_id }.merge(
+              given_resource_attributes
+            ).with_indifferent_access
+          end
+
+          collections[collection_name][resource_id]
+        end
+
+        # Éste método es útil para llamar "stub_request", usando el host+port configurado por ENV["NARANYA_ECM_SITE"]
+        def self.url_matcher
+          @url_matcher ||= begin
+            site_url = URI config.api_host
+            pattern_string = site_url.host
+            pattern_string += ":#{site_url.port}" unless site_url.port == 80
+            Regexp.new pattern_string, "i"
+          end
+        end
+
+        def self.get_resource(resource_type, resource_id)
+          collection_name = resource_type.pluralize
+          requested_resource = self.collections[collection_name.to_s].fetch resource_id, nil
+
+          # Traerse los MR's:
+          requested_resource[:media_resources] = self.media_resources.values.select do |mr|
+            mr[:parent_document_type] == "Content" && mr[:parent_document_id] == resource_id
+          end.map do |mr|
+            mr[:media_resources] = self.media_resources.values.select do |c_mr|
+              c_mr[:parent_document_type] == "MediaResource" && c_mr[:parent_document_id] == mr[:id]
+            end
+            mr
+          end if requested_resource.present? && collection_name == 'contents'
+
+          requested_resource
+        end
+
+        def self.get_resource_headers(collection_name, resource_id)
+          raise "no collection name given" unless collection_name.present?
+          raise "no resource id given" unless resource_id.present?
+
+          headers = {}
+          headers = {
+            "X-Frame-Options"         => "SAMEORIGIN",
+            "X-Xss-Protection"        => "1; mode=block",
+            "X-Content-Type-Options"  => "nosniff",
+            "Location"                => "http://ecm.naranya.net:5000/#{collection_name}/#{resource_id}",
+            "Content-Type"            => "application/json; charset=utf-8",
+            "Vary"                    => "Accept-Encoding",
+            "Etag"                    => '"a547f3ead872de01928f79724390aba4"',
+            "Cache-Control"           => "max-age=0, private, must-revalidate",
+            "Set-Cookie"              => "request_method=POST; path=/",
+            "X-Request-Id"            => "a6463225-df54-450d-b571-7068f3c96364",
+            "X-Runtime"               => "'0.241093'",
+            "Transfer-Encoding"       => "chunked"
+          } if self.collections[collection_name].key? resource_id
+        end
+
+        delegate  :collections, :get_resource, :get_resource_headers,
+                  :upsert_resource, to: :class
+
+        # Servicio de token de oauth:
+        # Responderá con un token "fake" de prueba...
+        post "/oauth/token" do
+          case params[:grant_type]
+          when "client_credentials"
+            status 201
+
+            headers \
+              "X-Frame-Options" => "SAMEORIGIN",
+              "X-XSS-Protection" => "1; mode=block",
+              "X-Content-Type-Options" => "nosniff",
+              "Cache-Control" => "no-store",
+              "Pragma" => "no-cache",
+              "Content-Type" => "application/json; charset=utf-8",
+              "Vary" => "Accept-Encoding",
+              "ETag" => '"75e236bc0e47293b0bfbb7a5d16a06c3"',
+              "X-Request-Id" => "f4d38d78-84b9-4c41-8943-cf2c6f519061",
+              "X-Runtime" => "0.015009",
+              "Transfer-Encoding" => "chunked"
+
+            body ActiveSupport::JSON.encode(
+              access_token:  "NContentClientTestAccessTokenA",
+              refresh_token: "NContentClientTestRefreshToken",
+              token_type:    "bearer",
+              expires_in:    7200
+            )
+          else
+            status 401
+          end
+
+        end
+
+        get '/:collection_name.json' do
+          status 200
+
+          headers \
+            "X-Frame-Options"         => "SAMEORIGIN",
+            "X-Xss-Protection"        => "1; mode=block",
+            "X-Content-Type-Options"  => "nosniff",
+            "Content-Type"            => "application/json; charset=utf-8",
+            "Vary"                    => "Accept-Encoding",
+            "Etag"                    => '"d751713988987e9331980363e24189ce"',
+            "Cache-Control"           => "max-age=0, private, must-revalidate",
+            "Set-Cookie"              => "request_method=GET; path=/",
+            "X-Request-Id"            => "4fe9e39f-2b2d-400f-9da7-0b9ad611ce26",
+            "X-Runtime"               => "'0.019181'",
+            "Transfer-Encoding"       => "chunked"
+
+          body ActiveSupport::JSON.encode collections[params[:collection_name]].values
+
+        end
+
+        post "/:collection_name.json" do
+          collection_name = params[:collection_name]
+          params = ActiveSupport::JSON.decode request.body.read
+          attributes = params[collection_name.singularize]
+
+          if attributes.present?
+            begin
+              resource = upsert_resource collection_name, attributes
+              status 201
+              headers get_resource_headers collection_name, resource[:id]
+              body ActiveSupport::JSON.encode resource
+            rescue ValidationError => e
+              status 422
+              body ActiveSupport::JSON.encode e.errors
+            end
+          else
+            status 422
+          end
+
+        end
+
+        get "/:collection_name/:id.json" do
+          resource = get_resource params[:collection_name], params[:id]
+          if resource.present?
+            status 201
+            headers get_resource_headers params[:collection_name], resource[:id]
+            body ActiveSupport::JSON.encode resource
+          else
+            status 404
+          end
+        end
+
+        put '/:collection_name/:id.json' do
+
+          collection_name = params[:collection_name]
+          resource_id     = params[:id]
+
+          if collection_name != 'download_authorizations' and resource = get_resource(collection_name, resource_id)
+
+            params = ActiveSupport::JSON.decode(request.body.read)
+
+            if attributes = params[collection_name.singularize]
+              begin
+                resource = upsert_resource collection_name, attributes, resource_id
+                status 200
+                headers get_resource_headers collection_name, resource[:id]
+                body ActiveSupport::JSON.encode resource
+              rescue ValidationError => e
+                status 422
+                body ActiveSupport::JSON.encode e.errors
+              end
+            else
+              status 422
+            end
+
+          else
+            status 404
+          end
+        end
+
+        get // do
+          byebug
+        end
+      end
+
+    end
+  end
+end

data/naranya_ecm-sdk.gemspec

@@ -1,7 +1,6 @@
 # coding: utf-8
 lib = File.expand_path("../lib", __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-
 require "naranya_ecm-sdk/version"
 
 Gem::Specification.new do |spec|
@@ -9,26 +8,41 @@ Gem::Specification.new do |spec|
   spec.version       = NaranyaEcm::VERSION
   spec.authors       = ["Roberto Quintanilla"]
   spec.email         = ["roberto.quintanilla@naranya.com"]
+
   spec.summary       = %q{Cliente Ruby de NaranyaEcm}
   spec.description   = %q{Cliente Ruby de NaranyaEcm para aplicaciones cliente.}
   spec.homepage      = "http://naranya.com"
   spec.license       = "MIT"
 
-  spec.files         = `git ls-files -z`.split("\x0")
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  # Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host', or
+  # delete this section to allow pushing this gem to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata['allowed_push_host'] = "https://rubygems.org"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
+  end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.bindir        = "exe"
   spec.require_paths = ["lib"]
 
   spec.add_dependency "activesupport",  "~> 4.0",   ">= 4.0.5"
   spec.add_dependency "activemodel",    "~> 4.0",   ">= 4.0.5"
-  spec.add_dependency "httparty",       "~> 0.13",  ">= 0.13.1"
+
+  spec.add_dependency "oauth2",         "~> 1.0"
+  # which uses Faraday as it's client... we get to choose which HTTP driver to use!
+
   spec.add_dependency "aasm",           "~> 3.2",   ">= 3.2.1"
   spec.add_dependency "fog-core",       "1.25.0"
   spec.add_dependency "fog",            "~> 1.22",  ">= 1.22.1"
 
-  spec.add_development_dependency "bundler",  "~> 1.6"
-  spec.add_development_dependency "rake",     "~> 10.3"
-  spec.add_development_dependency "rspec",    "~> 3.0"
-  spec.add_development_dependency "vcr",      "~> 2.9"
-  spec.add_development_dependency "webmock",  "~> 1.18"
+  spec.add_development_dependency "bundler",      "~> 1.6"
+  spec.add_development_dependency "rake",         "~> 10.3"
+  spec.add_development_dependency "factory_girl", "~> 4.5"
+  spec.add_development_dependency "rspec",        "~> 3.2"
+  spec.add_development_dependency "sinatra",      "~> 1.4"
+  spec.add_development_dependency "bson",         "~> 3.0"
+
+  spec.add_development_dependency "webmock",      "~> 1.18"
 end