kishu 0.0.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3a738103de7f2e4cec1383479b44f90021c55664ebfc7c064e60e150fd985715
-  data.tar.gz: b17875c128c0257247f954ccee38eb31014dd32e64f3bcec2a106e75d1673f76
+  metadata.gz: 45d4e6ad0c84d9c3dfaef319fb4321bbaf9d6623b8ef810420af2b1e0779fea8
+  data.tar.gz: 9672d38f55253112c443b17da56e35c7469211ee9a90f9dbc8844e1a4bf67eae
 SHA512:
-  metadata.gz: 6bfe9b3b87dc67ba255e5e99bb620de1366a7a0284cff49ec3483d721747205eef50c349bb6ad58decc04925afa99d179c81fe42aa34cb1b15b1dde767dfd1ff
-  data.tar.gz: 3a4fc34fae1f85ad6c5129446830d03703565f5c1fea7dfb8635b21ba4a6c85370a378250783752c864154908bc11c69f9a194bd376961287a4491900514fd20
+  metadata.gz: 7727dafcfe5f6fbda41a4a5d1d634419e6fdd23afb122c6452c9156e8644bef6999d1527ba74f42237a9f5ee0cf9388fb8231bcea35b99fce70e3a32c716fb28
+  data.tar.gz: 0dd429d67bae7d4557a04d2b4d4e19d729383571b33d6340dadb9220734888214ede9bac1fa37e9f18e1dc53eec07017f30b13539b899c98b0d75256ae931340

data/.gitignore

@@ -34,3 +34,4 @@
 reports/datacite_resolution_report_2018-04.json
 reports/datacite_resolution_report_2018-08.json
 reports/datacite_resolution_report_2018-08_2.json
+.gem

data/.travis.yml

@@ -1,7 +1,17 @@
----
-sudo: false
 language: ruby
-cache: bundler
 rvm:
-  - 2.3.3
-before_install: gem install bundler -v 1.16.4
+- 2.3.1
+install:
+- travis_retry bundle install
+# script: bundle exec rspec
+notifications:
+  slack: "$SLACK_TOKEN"
+  email: false
+deploy:
+  provider: rubygems
+  api_key:
+    secure: "$RUBYGEMS_KEY"
+  gem: kishu
+  on:
+    tags: true
+    repo: datacite/kishu

data/README.md

@@ -22,7 +22,33 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+
+First setup your JWT and the host to send reports
+
+```
+export HUB_TOKEN="nsdfkhdfs89745fdfdsDFSFDS"
+export HUB_URL="https://api.test.datacite.org"
+
+```
+
+You can generate a usage report locally with:
+
+```shell
+kishu sushi generate created_by:{YOUR DATACITE CLIENT ID}
+```
+
+To generate and push a usage report in JSON format following the Code of Practice for Usage Metrics, you can use the following command. 
+
+```shell
+kishu sushi push created_by:{YOUR DATACITE CLIENT ID}
+```
+
+To stream a usage report in JSON format following the Code of Practice for Usage Metrics, you can use the following command. This option should be only used with reports with more than 50,000 datasets or larger than 10MB. We compress all reports that are streammed to the the MDC Hub.
+
+```shell
+kishu sushi stream created_by:{YOUR DATACITE CLIENT ID}
+```
+
 
 ## Development
 
@@ -36,7 +62,7 @@ Follow along via [Github Issues](https://github.com/datacite/kishu/issues).
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/kishu. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+Bug reports and pull requests are welcome on GitHub at https://github.com/datacite/kishu. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
 
 ## License
 

data/lib/kishu.rb

@@ -27,4 +27,4 @@ AWS_ACCESS_KEY_ID         = ENV['AWS_ACCESS_KEY_ID'] ? ENV['AWS_ACCESS_KEY_ID']
 AWS_SECRET_ACCESS_KEY     = ENV['AWS_SECRET_ACCESS_KEY'] ? ENV['AWS_SECRET_ACCESS_KEY'] : ""
 ELASTIC_PASSWORD          = ENV['ELASTIC_PASSWORD'] ? ENV['ELASTIC_PASSWORD'] : ""
 LOGS_TAG  = "[Resolution Logs]"
-puts ENV.to_a
+LOGGER = Logger.new(STDOUT)

data/lib/kishu/client.rb

@@ -11,7 +11,7 @@ module Kishu
     def initialize
 
       if ES_HOST == "localhost:9200" || ES_HOST == "elasticsearch:9200"
-        @client = Elasticsearch::Client.new(host: ES_HOST, user: "elastic", password: ELASTIC_PASSWORD, transport_options: { request: { timeout: 3600, open_timeout: 3600 }}) do |f|
+        @client = Elasticsearch::Client.new(host: ES_HOST, user: "elastic", password: ELASTIC_PASSWORD, transport_options: { request: { timeout: 3600}}) do |f|
           f.adapter Faraday.default_adapter
         end
       else
@@ -62,8 +62,7 @@ module Kishu
             query_string: {
               query: "*"
             }
-          },
-          aggregations: aggregations(options)
+          }
         },
         index: "resolutions"
         ).dig("hits","hits",0,"_source","logdate")

data/lib/kishu/report.rb

@@ -13,6 +13,7 @@ module Kishu
 
     include Kishu::Base
     include Kishu::Utils
+    attr_reader :uid, :total, :period
 
     def initialize options={}
       set_period 
@@ -21,8 +22,17 @@ module Kishu
       @report_id = options[:report_id] ? options[:report_id] : ""
       @total = 0
       @aggs_size = options[:aggs_size] 
-      @chunk_size = options[:chunk_size]
       @after = options[:after_key] ||=""
+      @enrich = options[:enrich] 
+      @schema = options[:schema] 
+      @encoding = options[:encoding] 
+      @created_by = options[:created_by] 
+      @report_size = options[:report_size] 
+      if @schema == "resolution" 
+        @enrich = false
+        @encoding = "gzip"
+        # @report_size = 20000
+      end
     end
 
     def report_period options={}
@@ -37,10 +47,13 @@ module Kishu
     def get_events options={}
       logger = Logger.new(STDOUT)
       es_client = Client.new()
-      response = es_client.get({aggs_size: @aggs_size || 500, after_key: options[:after_key] ||=""})
+      response = es_client.get({aggs_size: @aggs_size || 400, after_key: options[:after_key] ||=""})
       aggs = response.dig("aggregations","doi","buckets")
       x = aggs.map do |agg|
-        ResolutionEvent.new(agg,{period: @period, report_id: @report_id}).wrap_event
+        case @schema
+          when "resolution" then ResolutionEvent.new(agg,{period: @period, report_id: @report_id}).wrap_event
+          when "usage"      then UsageEvent.new(agg,{period: @period, report_id: @report_id}).wrap_event
+        end
       end
       after = response.dig("aggregations","doi").fetch("after_key",{"doi"=>nil}).dig("doi")
       logger.info "After_key for pagination #{after}"
@@ -56,13 +69,24 @@ module Kishu
         @datasets = @datasets.concat response[:data]
         @after = response[:after]
         @total += @datasets.size
-        generate_chunk_report if @datasets.size > @chunk_size
+        generate_chunk_report if @datasets.size > @report_size
+        break if @after.nil?
+      end
+    end
+
+    def generate
+      @datasets = []
+      loop do
+        response = get_events({after_key: @after ||=""})
+        @datasets = @datasets.concat response[:data]
+        @after = response[:after]
+        @total += @datasets.size
+        break if @total > 40000
         break if @after.nil?
       end
     end
 
     def compress report
-      # report = File.read(hash)
       gzip = Zlib::GzipWriter.new(StringIO.new)
       string = report.to_json
       gzip << string
@@ -82,17 +106,12 @@ module Kishu
       @datasets = []
     end
 
-    def make_report options={}
-      generate_dataset_array
-      @logger.info  "#{LOGS_TAG} Month of #{@period.dig("begin-date")} sent to Hub in report #{@uid} with stats for #{@total} datasets"
-    end
-
 
     def set_period 
-      report_period
+      rp = report_period
       @period = { 
-        "begin-date": Date.civil(report_period.year, report_period.mon, 1).strftime("%Y-%m-%d"),
-        "end-date": Date.civil(report_period.year, report_period.mon, -1).strftime("%Y-%m-%d"),
+        "begin-date": Date.civil(rp.year, rp.mon, 1).strftime("%Y-%m-%d"),
+        "end-date": Date.civil(rp.year, rp.mon, -1).strftime("%Y-%m-%d"),
       }
     end
 
@@ -100,13 +119,22 @@ module Kishu
       uri = HUB_URL+'/reports'   
       puts uri
 
-      headers = {
-        content_type: "application/gzip",
-        content_encoding: 'gzip',
-        accept: 'gzip'
-      }
-      
-      body = compress(report)
+      case @encoding 
+        when "gzip" then
+          headers = {
+            content_type: "application/gzip",
+            content_encoding: 'gzip',
+            accept: 'gzip'
+          }
+          body = compress(report)
+        when "json" then
+          headers = {
+            content_type: "application/json",
+            accept: 'application/json'
+          }
+          body = report
+      end
+
       n = 0
       loop do
         request = Maremma.post(uri, data: body,
@@ -114,6 +142,9 @@ module Kishu
           headers: headers,
           timeout: 100)
 
+        puts body
+        puts headers
+
         @uid = request.body.dig("data","report","id")
         @logger.info "#{LOGS_TAG} Hub response #{request.status} for Report finishing in #{@after}"
         @logger.info "#{LOGS_TAG} Hub response #{@uid} for Report finishing in #{@after}"
@@ -132,12 +163,16 @@ module Kishu
     end
 
     def get_header 
+      report_type = case @schema
+        when "resolution" then {release:"drl", title:"resolution report"}
+        when "usage"      then {release:"rd1", title:"usage report"}
+      end 
       {
-        "report-name": "resolution report",
+        "report-name": report_type.dig(:title),
         "report-id": "dsr",
-        release: "drl",
+        release: report_type.dig(:release),
         created: Date.today.strftime("%Y-%m-%d"),
-        "created-by": "datacite",
+        "created-by": @created_by,
         "reporting-period": @period,
         "report-filters": [],
         "report-attributes": [],

data/lib/kishu/resolution_event.rb

@@ -41,7 +41,7 @@ module Kishu
     
         @doi = dataset.fetch(:doi,nil)
 
-        data = {}
+      
         instances =[
           {
             "count" => dataset.fetch(:total_counts_regular),

data/lib/kishu/sushi.rb

@@ -14,24 +14,6 @@ module Kishu
   include Kishu::Utils
 
 
-   desc "get sushi", "get resolution report"
-  #  method_option :username, :default => ENV['MDS_USERNAME']
-   method_option :aggs_size, :type => :numeric, :default => 1000
-   method_option :month_year, :type => :string, :default => "2018-04"
-   def get
-    x =Report.new()
-    x.make_report(options)
-    
-   end
-
-   method_option :month_year, :type => :string, :default => "2018-04"
-   method_option :after_key, :type => :string
-   def continue_report
-    x =Report.new()
-    x.generate_files(options)
-    
-   end
-
    desc "clean_all sushi", "clean index"
    method_option :month_year, :type => :string, :default => "2018-04"
    method_option :after_key, :type => :string
@@ -41,19 +23,55 @@ module Kishu
     
    end
 
+   desc "stream a sushi", "stream report"
+   method_option :month_year,  :type => :string, :default => "2018-04"
+   method_option :after_key,   :type => :string
+   method_option :report_size, :type => :numeric, :default => 40000
+   method_option :aggs_size,   :type => :numeric, :default => 500
+   method_option :schema,      :type => :string, :default => "usage"
+   method_option :enrich,      :type => :boolean, :default => false
+   method_option :encoding,     :type => :string, :default => "gzip"
+   method_option :created_by,  :type => :string, :default => "datacite"
+   def stream
+    fail "You need to set your JWT" if HUB_TOKEN.blank?
+    report = Report.new(options)
+    report.generate_dataset_array
+    LOGGER.info  "#{LOGS_TAG} Month of #{report.period.dig("begin-date")} sent to Hub in report #{report.uid} with stats for #{report.total} datasets"
+   end
 
-   desc "send_report_events sushi", "send_report_events index"
-   method_option :month_year, :type => :string, :default => "2018-04"
-   method_option :after_key, :type => :string
-   method_option :chunk_size, :type => :numeric, :default => 40000
-   method_option :aggs_size, :type => :numeric, :default => 500
-   def send_report_events
+   desc "generate a sushi", "generate report"
+   method_option :schema,      :type => :string, :default => "usage"
+   method_option :enrich,      :type => :boolean, :default => true
+   method_option :encoding,     :type => :string, :default => "json"
+   method_option :created_by,  :type => :string, :default => "datacite"
+   def generate
+    report = Report.new(options)
+    report.generate
+    file = report.merged_file
+    File.open(file,"w") do |f|
+      f.write(JSON.pretty_generate report.get_template)
+    end
+    LOGGER.info  "#{LOGS_TAG} Month of #{report.period.dig("begin-date")} with stats for #{report.total} datasets"
+   end
+
+   desc "push a sushi", "push report"
+   method_option :schema,      :type => :string, :default => "usage"
+   method_option :enrich,      :type => :boolean, :default => true
+   method_option :encoding,     :type => :string, :default => "json"
+   method_option :created_by,  :type => :string, :default => "datacite"
+   def push
     fail "You need to set your JWT" if HUB_TOKEN.blank?
-    x =Report.new(options)
-    x.make_report(options)
-    
+    report = Report.new(options)
+    report.generate
+    report.send_report report.get_template
+    LOGGER.info  "#{LOGS_TAG} Month of #{report.period.dig("begin-date")} sent to Hub in report #{report.uid} with stats for #{report.total} datasets"
+   end
+
+   desc "is ES running", "check es is working" 
+   def elasticsearch_results
+    es = Client.get({aggs_size: 10, after_key: ""})
+    puts es
    end
 
-   
   end
 end

data/lib/kishu/usage_event.rb

@@ -10,98 +10,114 @@ module Kishu
 
     API_URL = "https://api.datacite.org"
     
-    def wrap_event(event)
-      puts "------------------ \n"
-      totale = event.dig("totale").fetch("buckets", [])
-      # puts event.dig("unique").fetch("buckets", nil)
-      unique = event.dig("unique").fetch("buckets", [])
-      # puts unique[1].dig('key')
+    def wrap_event(event, options={})
+      totale_investigations = event.dig("totale").fetch("buckets", [])
+      unique_investigations = event.dig("unique").fetch("buckets", [])
     
-      unique_regular = unique.find_all {|access_method| access_method.fetch('key',"").match('regular') }
-      unique_machine = unique.find_all {|access_method| access_method.fetch('key',"").match('machine') }
-      total_regular  = totale.find_all {|access_method| access_method.fetch('key',"").match('regular') }
-      total_machine  = totale.find_all {|access_method| access_method.fetch('key',"").match('machine') }
+      unique_regular_investigations = unique_investigations.find_all {|access_method| access_method.fetch('key',"").match('regular') }
+      unique_machine_investigations = unique_investigations.find_all {|access_method| access_method.fetch('key',"").match('machine') }
+      total_regular_investigations  = totale_investigations.find_all {|access_method| access_method.fetch('key',"").match('regular') }
+      total_machine_investigations  = totale_investigations.find_all {|access_method| access_method.fetch('key',"").match('machine') }
+
+      totale_requests = event.dig("totale").fetch("buckets", [])
+      unique_requests = event.dig("unique").fetch("buckets", [])
+    
+      unique_regular_requests = unique_requests.find_all {|access_method| access_method.fetch('key',"").match('regular') }
+      unique_machine_requests = unique_requests.find_all {|access_method| access_method.fetch('key',"").match('machine') }
+      total_regular_requests  = totale_requests.find_all {|access_method| access_method.fetch('key',"").match('regular') }
+      total_machine_requests  = totale_requests.find_all {|access_method| access_method.fetch('key',"").match('machine') }
 
       dataset = { 
         doi: event.dig("key","doi"), 
-        unique_counts_regular: unique_regular.empty? ? 0 : unique_regular.size,
-        unique_counts_machine: unique_machine.empty? ? 0 : unique_machine.size,
-        total_counts_regular: total_regular.empty? ? 0 : total_regular.dig(0,"doc_count"),
-        total_counts_machine: total_machine.empty? ? 0:  total_machine.dig(0,"doc_count")
+        unique_counts_regular_investigations: unique_regular_investigations.empty? ? 0 : unique_regular_investigations.size,
+        unique_counts_machine_investigations: unique_machine_investigations.empty? ? 0 : unique_machine_investigations.size,
+        total_counts_regular_investigations: total_regular_investigations.empty? ? 0 : total_regular_investigations.dig(0,"doc_count"),
+        total_counts_machine_investigations: total_machine_investigations.empty? ? 0:  total_machine_investigations.dig(0,"doc_count"),
+        unique_counts_regular_requests: unique_regular_requests.empty? ? 0 : unique_regular_requests.size,
+        unique_counts_machine_requests: unique_machine_requests.empty? ? 0 : unique_machine_requests.size,
+        total_counts_regular_requests: total_regular_requests.empty? ? 0 : total_regular_requests.dig(0,"doc_count"),
+        total_counts_machine_requests: total_machine_requests.empty? ? 0:  total_machine_requests.dig(0,"doc_count")
       }
 
-    
       # conn = Faraday.new(:url => API_URL)
       logger = Logger.new(STDOUT)
       logger.info event.fetch("doc_count")
       
-      # arr = dois.map do |dataset| 
-        logger.info dataset
-        doi = dataset.fetch(:doi,nil)
-        # json = conn.get "/works/#{doi}"
-        # json = conn.get do |req|
-        #   req.url "/works/#{doi}"
-        #   req.options.timeout = 50           # open/read timeout in seconds
-        #   req.options.open_timeout = 20      # connection open timeout in seconds
-        # end
-        # json = Maremma.get "#{API_URL}/works/#{doi}"
-        # logger.info json.status
+      logger.info dataset
 
-        # return {} unless json.status == 200 
-        # logger.info "Success on getting metadata for #{doi}"
-        # data = JSON.parse(json.body)
-        # data = json.body
-        data = {}
-        instances =[
-          {
-            count: dataset.fetch(:total_counts_regular),
-            "access-method": "regular",
-            "metric-type": "total-resolutions"
-          },
-          {
-            count: dataset.fetch(:unique_counts_regular),
-            "access-method": "regular",
-            "metric-type": "unique-resolutions"
-          },
-          {
-            count: dataset.fetch(:unique_counts_machine),
-            "access-method": "machine",
-            "metric-type": "unique-resolutions"
-          },
-          {
-            count: dataset.fetch(:total_counts_machine),
-            "access-method": "machine",
-            "metric-type": "total-resolutions"
-          },
-        ]
-    
-        instances.delete_if {|instance| instance.dig(:count) <= 0}
-        attributes = {} #data.dig("data","attributes")
-        resource_type = "" #attributes.fetch("resource-type-id",nil).nil? ? "dataset" : attributes.fetch("resource-type-id",nil)
+      doi = dataset.fetch(:doi,nil)
+
+      data = get_metadata doi
 
-        instanced = { 
-          "dataset-id" => [{type: "doi", value: dataset.fetch(:doi,nil)}],
-          "data-type" => resource_type,
-          yop: attributes.fetch("published",nil),
-          uri: attributes.fetch("identifier",nil),
-          publisher: attributes.fetch("container-title",nil),
-          "dataset-title": attributes.fetch("title",nil),
-          "publisher-id": [{
-            type: "client-id",
-            value: attributes.fetch("data-center-id",nil)
-          }],
-          "dataset-dates": [{
-            type: "pub-date",
-            value: attributes.fetch("published",nil)
-          }],
-          "dataset-contributors": attributes.fetch("author",[]).map { |a| get_authors(a) },
-          platform: "datacite",
-          performance: [{
-            period: @period,
-            instance: instances
-          }]
+      instances =[
+        {
+          "count": dataset[:total_counts_regular_investigations],
+          "access-method": "regular",
+          "metric-type": "total_dataset_investigations"
+        },
+        {
+          "count": dataset[:unique_counts_regular_investigations],
+          "access-method": "regular",
+          "metric-type": "unique_dataset_investigations"
+        },
+        {
+          "count": dataset[:unique_counts_machine_investigations],
+          "access-method": "machine",
+          "metric-type": "unique_dataset_investigations"
+        },
+        {
+          "count": dataset[:total_counts_machine_investigations],
+          "access-method": "machine",
+          "metric-type": "total_dataset_investigations"
+        },
+        {
+          "count": dataset[:total_counts_regular],
+          "access-method": "regular",
+          "metric-type": "total_dataset_requests"
+        },
+        {
+          "count": dataset[:unique_counts_regular],
+          "access-method": "regular",
+          "metric-type": "unique_dataset_requests"
+        },
+        {
+          "count": dataset[:unique_counts_machine],
+          "access-method": "machine",
+          "metric-type": "unique_dataset_requests"
+        },
+        {
+          "count": dataset[:total_counts_machine],
+          "access-method": "machine",
+          "metric-type": "total_dataset_requests"
         }
-        logger.info instanced
+      ]
+      instances.delete_if {|instance| instance.dig(:count) <= 0}
+      attributes = data.dig("data","attributes")
+      resource_type = attributes.fetch("resource-type-id",nil).nil? ? "dataset" : attributes.fetch("resource-type-id",nil)
+
+      instanced = { 
+        "dataset-id" => [{type: "doi", value: dataset.fetch(:doi,nil)}],
+        "data-type" => resource_type,
+        "yop" => attributes.fetch("published",nil),
+        "uri" => attributes.fetch("identifier",nil),
+        "publisher" => attributes.fetch("container-title",nil),
+        "dataset-title": attributes.fetch("title",nil),
+        "publisher-id": [{
+          "type" => "client-id",
+          "value" => attributes.fetch("data-center-id",nil)
+        }],
+        "dataset-dates": [{
+          "type" => "pub-date",
+          "value" => attributes.fetch("published",nil)
+        }],
+        "dataset-contributors": attributes.fetch("author",[]).map { |a| get_authors(a) },
+        "platform" => attributes.fetch("data-center-id",nil),
+        "performance" => [{
+          "period" => @period,
+          "instance" => instances
+        }]
+      }
+      logger.info instanced
 
       instanced
     end
@@ -119,6 +135,13 @@ module Kishu
             value: "" }
       end
     end
-  
+
+    def get_metadata doi
+      json = Maremma.get "#{API_URL}/works/#{doi}"
+      logger.info json.status
+      return {} unless json.status == 200 
+      logger.info "Success on getting metadata for #{doi}"
+      JSON.parse(json.body)
+    end
   end
 end

data/lib/kishu/version.rb

@@ -1,3 +1,3 @@
 module Kishu
-  VERSION = "0.0.1"
+  VERSION = "1.0.0"
 end

data/spec/report_spec.rb

@@ -3,33 +3,7 @@ require 'spec_helper'
 
 describe Kishu::Report, vcr: true, :order => :defined do
   let(:report) {Kishu::Report.new()}
-  describe "report_period" do
-    context "when doi doesn't exist" do
-
-      it "should fail" do
-        # response = subject.get_events
-        # expect(response).to be({})
-      end
-    end
-  end
-
-
-  describe "get_events" do
-    context "" do
-      it "should return the data for one message" do
-  
-      end
-    end
-  end
-
-  describe "generate_dataset_array" do
-    context "" do
-      it "" do
-  
-      end
-    end
-  end
-
+ 
   describe "compress" do
     context "when json arrives compresses it correctly" do
       
@@ -39,38 +13,77 @@ describe Kishu::Report, vcr: true, :order => :defined do
     end
   end
 
-
-  describe "generate_chunk_report" do
-    context "" do
-      it "" do
-  
-      end
-    end
-  end
-
-  describe "set_period" do
-    context "" do
-      it "" do
-  
-      end
-    end
-  end
-
-  describe "send_report" do
-    context "when the report is good" do
-      it "" do
-  
-      end
-    end
-
-    context "when the report is bad" do
-      let(:report) {}
-      it "return error" do
-        # status = Report.send_report report
-        # expect(status).not_to eq("201")
-      end
-    end
-  end
+  # describe "get_template" do
+  #   context "when Godd Usage report" do
+  #     let(:usage_params) {{encoding:"json",schema:"usage",enrich:true,created_by:"DataOne"}}
+  #     let(:datasets) {fixture_file("usage_datasest_array.json")}
+  #     let(:period) {{}}
+  #     it "generate a good template" do
+  #       response = Report.new(usage_params)
+  #       response.datasets = datasets
+  #       expect(response.get_template.dig("report-header","release")).to eq("rd1")
+  #       expect(response.get_template.dig("report-header","created_by")).to eq("DataOne")
+  #       expect(response.get_template.dig("report-datasets").size).to eq(10)
+  #     end
+  #   end
+
+  #   context "when Godd Resolution report" do
+  #     let(:resolution_params) {{encoding:"json",schema:"resolution",enrich:false,created_by:"Dash"}}
+  #     let(:datasets) {fixture_file("usage_datasest_array.json")}
+  #     let(:period) {{}}
+  #     it "generate a good template" do
+  #       response = Report.new(resolution_params)
+  #       response.datasets = datasets
+  #       expect(response.get_template.dig("report-header","release")).to eq("dlr")
+  #       expect(response.get_template.dig("report-header","created_by")).to eq("Dash")
+  #       expect(response.get_template.dig("report-datasets").size).to eq(10)
+  #     end
+  #   end
+  #   context "when Bad Resolution report" do
+  #     let(:resolution_params) {{encoding:"json",schema:"resolution",enrich:false,created_by:"Dash"}}
+  #     let(:datasets) {fixture_file("usage_datasest_array.json")}
+  #     let(:period) {{}}
+  #     it "generate a good template" do
+  #       response = Report.new(resolution_params)
+  #       response.datasets = datasets
+  #       expect(response.get_template.dig("report-header","release")).to eq("dlr")
+  #       expect(response.get_template.dig("report-header","created_by")).to eq("Dash")
+  #       expect(response.get_template.dig("report-datasets").size).to eq(10)
+  #     end
+  #   end
+  # end
+
+  # describe "send_report" do
+  #   context "when Godd Usage report" do
+  #     let(:usage_params) {{encoding:"json",schema:"usage",enrich:true,created_by:"DataOne"}}
+  #     let(:datasets) {fixture_file("usage_datasest_array.json")}
+  #     let(:period) {{}}
+  #     it "return 200" do
+  #       report = Report.new(usage_params)
+  #       report.datasets = datasets
+  #       response = report.send_report
+  #       expect(response.status).to eq(201)  
+  #     end
+  #   end
+  #   context "when Godd Resolution report" do
+  #     let(:resolution_params) {{encoding:"json",schema:"resolution",enrich:false,created_by:"datacite"}}
+  #     let(:datasets) {fixture_file("usage_datasest_array.json")}
+  #     let(:period) {{}}
+  #     it "return 200" do
+  #       report = Report.new(resolution_params)
+  #       report.datasets = datasets
+  #       response = report.send_report
+  #       expect(response.status).to eq(201)  
+  #     end
+  #   end
+
+    # context "when the report is bad" do
+    #   it "return error" do
+    #     # status = Report.send_report report
+    #     # expect(status).not_to eq("201")
+    #   end
+    # end
+  # end
 
 end
 

data/spec/resolution_event_spec.rb

@@ -3,59 +3,59 @@ require 'spec_helper'
 
 describe Kishu::ResolutionEvent, vcr: true, :order => :defined do
 
-  describe "wrap_event" do
-    context "when doi exist" do
-      let(:event){create(:resolution_event)}
-      it "should wrap correctly" do
-        puts event.dig(:totale)
-        response = subject.wrap_event(event)
-        expect(response).to eq({})
-      end
-    end
-    context "when doi has not type assigned" do
-      let(:event) {{
-        "key": {
-          "doi": "10.13130//3192"
-        },
-        "doc_count": 2,
-        "totale": {
-          "doc_count_error_upper_bound": 0,
-          "sum_other_doc_count": 0,
-          "buckets": [
-            {
-              "key": "10.13130//3192_regular",
-              "doc_count": 2
-            }
-          ]
-        },
-        "unqiue": {
-          "doc_count_error_upper_bound": 0,
-          "sum_other_doc_count": 0,
-          "buckets": [
-            {
-              "key": "2018-04-15_12_10.13130//3192_5.168.132.15_Mozilla/5.0 (Linux; Android 6.0.1; SAMSUNG SM-A520F Build/MMB29K) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/5.4 Chrome/51.0.2704.106 Mobile Safari/537.36_regular",
-              "doc_count": 1
-            },
-            {
-              "key": "2018-04-15_16_10.13130//3192_151.15.225.227_Mozilla/5.0 (iPhone; CPU iPhone OS 11_3 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/11.0 Mobile/15E148 Safari/604.1_regular",
-              "doc_count": 1
-            }
-          ]
-        }
-      }}
-      it "should return an dataset event" do
-        response = ResolutionEvent.wrap_event(event)
-        expect(response).to eq({})
-      end
-    end
-    context "when event is empty" do
-      let(:event) {""}
-      it "should fail" do
-        response = ResolutionEvent.wrap_event(event)
-        expect(response).to eq({})
-      end
-    end
-  end
+  # describe "wrap_event" do
+  #   context "when doi exist" do
+  #     let(:event){create(:resolution_event)}
+  #     it "should wrap correctly" do
+  #       puts event.dig(:totale)
+  #       response = subject.wrap_event(event)
+  #       expect(response).to eq({})
+  #     end
+  #   end
+  #   context "when doi has not type assigned" do
+  #     let(:event) {{
+  #       "key": {
+  #         "doi": "10.13130//3192"
+  #       },
+  #       "doc_count": 2,
+  #       "totale": {
+  #         "doc_count_error_upper_bound": 0,
+  #         "sum_other_doc_count": 0,
+  #         "buckets": [
+  #           {
+  #             "key": "10.13130//3192_regular",
+  #             "doc_count": 2
+  #           }
+  #         ]
+  #       },
+  #       "unqiue": {
+  #         "doc_count_error_upper_bound": 0,
+  #         "sum_other_doc_count": 0,
+  #         "buckets": [
+  #           {
+  #             "key": "2018-04-15_12_10.13130//3192_5.168.132.15_Mozilla/5.0 (Linux; Android 6.0.1; SAMSUNG SM-A520F Build/MMB29K) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/5.4 Chrome/51.0.2704.106 Mobile Safari/537.36_regular",
+  #             "doc_count": 1
+  #           },
+  #           {
+  #             "key": "2018-04-15_16_10.13130//3192_151.15.225.227_Mozilla/5.0 (iPhone; CPU iPhone OS 11_3 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/11.0 Mobile/15E148 Safari/604.1_regular",
+  #             "doc_count": 1
+  #           }
+  #         ]
+  #       }
+  #     }}
+  #     it "should return an dataset event" do
+  #       response = ResolutionEvent.wrap_event(event)
+  #       expect(response).to eq({})
+  #     end
+  #   end
+  #   context "when event is empty" do
+  #     let(:event) {""}
+  #     it "should fail" do
+  #       response = ResolutionEvent.wrap_event(event)
+  #       expect(response).to eq({})
+  #     end
+  #   end
+  # end
 
 
   describe "" do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kishu
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Kristian Garza
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-12-06 00:00:00.000000000 Z
+date: 2018-12-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -387,14 +387,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 2.7.8
 signing_key: 
 specification_version: 4
 summary: Client for DOI Resolution Logs processing pipeline
-test_files:
-- spec/factories/default.rb
-- spec/fixtures/vcr_cassettes/Kishu_Sushi/wrap_event/when_doi_doesn_t_exist/should_fail.yml
-- spec/kishu_spec.rb
-- spec/report_spec.rb
-- spec/resolution_event_spec.rb
-- spec/spec_helper.rb
+test_files: []