watsbot 1.0.0

data/lib/watsbot/message.rb

@@ -0,0 +1,47 @@
+require "httparty"
+require "celluloid"
+
+module Watsbot
+  class Message < BaseResource
+    include HTTParty
+
+    def send(uid, message, context={})
+      raise "uid should be provided" and return if uid.nil? or uid.empty?
+      raise "message should be provided" and return if message.nil? or message.empty?
+
+      future = Celluloid::Future.new { call(uid, message, context={}) }
+      future.value
+    end
+
+    private
+
+      def call(uid, message, context={})
+        state = State.instance
+        context = JSON.parse(state.fetch(uid)) rescue nil
+        response = call_api(message, context)
+        change_state(state, uid, response)
+        response
+      end
+
+      def change_state(state, uid, response)
+        if response.is_a? Response::Success
+          if response.context["system"]["branch_exited_reason"] == 'completed'
+            state.delete(uid)
+          elsif response.context["system"]["branch_exited_reason"] != 'fallback'
+            state.store(uid, response.context.to_json)
+          end
+        else
+          state.delete(uid)
+        end
+      end
+
+      def call_api(message, context={})
+        body = { input: { text: message }, context: context }
+        options = { basic_auth: basic_auth, headers: headers, body: body.to_json }
+        response = self.class.post("/workspaces/#{Watsbot.configuration.workspace}/message?version=#{Watsbot.configuration.version}", options)
+        logger.info("/log/watsbot.log", "watson api _> #{options.inspect} -- #{response}")
+        parser = Watsbot::Response::Parser.new response
+        parser.parse
+      end
+  end
+end

data/lib/watsbot/response/error.rb

@@ -0,0 +1,5 @@
+module Watsbot
+  module Response
+    Error = Struct.new(:code, :message) do; end
+  end
+end

data/lib/watsbot/response/parser.rb

@@ -0,0 +1,38 @@
+module Watsbot
+  module Response
+    class Parser
+
+      def initialize(response)
+        @response = response
+        @response_body = JSON.parse(response.body)
+      end
+
+      def parse
+        if @response.code >= 400
+          response = Error.new @response.code
+          response.message = parse_error_message
+          response
+        else
+          response = Success.new @response.code
+          response.intents = @response_body["intents"]
+          response.entities = parse_entities
+          response.input = @response_body["input"]
+          response.output = @response_body["output"]
+          response.context = @response_body["context"]
+          response
+        end
+      end
+
+      private
+
+        def parse_error_message
+          @response_body["error"]["error"] rescue ""
+        end
+
+        def parse_entities
+          @response_body["entities"]
+        end
+
+    end
+  end
+end

data/lib/watsbot/response/success.rb

@@ -0,0 +1,5 @@
+module Watsbot
+  module Response
+    Success = Struct.new(:code, :intents, :entities, :input, :output, :context) do; end
+  end
+end

data/lib/watsbot/state.rb

@@ -0,0 +1,29 @@
+require "redis"
+require "singleton"
+
+module Watsbot
+  class State
+    include Singleton
+
+    def initialize
+      @redis = Redis.new(:url => Watsbot.configuration.redis_url)
+    end
+
+    def fetch(key)
+      @redis.get(key)
+    end
+
+    def store(key, value)
+      @redis.set(key, value)
+    end
+
+    def exists?(key)
+      @redis.exists(key)
+    end
+
+    def delete(key)
+      @redis.del(key)
+    end
+
+  end
+end

data/lib/watsbot/version.rb

@@ -0,0 +1,3 @@
+module Watsbot
+  VERSION = "1.0.0"
+end

data/spec/configuration_spec.rb

@@ -0,0 +1,149 @@
+require "spec_helper"
+
+module Watsbot
+  RSpec.describe Configuration do
+
+    after :each do
+      Watsbot.reset
+    end
+
+    context "username" do
+      it "should return default username from environment variable" do
+        allow(ENV).to receive(:[]).and_return(nil)
+        allow(ENV).to receive(:[]).with("WATSON_USERNAME").and_return("test")
+        Configuration.new.username
+        expect(Configuration.new.username).to eq("test")
+      end
+      it "should set username" do
+        config = Configuration.new
+        config.username = "test"
+        expect(config.username).to eq("test")
+      end
+      it "should set username with argument" do
+        config = Configuration.new username: "test"
+        expect(config.username).to eq("test")
+      end
+      it "should set username with block" do
+        config = Configuration.new do |c|
+          c.username = "username"
+        end
+        expect(config.username).to eq("username")
+      end
+    end
+
+    context "password" do
+      it "should return default password from environment variable" do
+        allow(ENV).to receive(:[]).and_return(nil)
+        allow(ENV).to receive(:[]).with("WATSON_PASSWORD").and_return("test")
+        Configuration.new.password
+        expect(Configuration.new.password).to eq("test")
+      end
+      it "should set password" do
+        config = Configuration.new
+        config.password = "test"
+        expect(config.password).to eq("test")
+      end
+      it "should set password with argument" do
+        config = Configuration.new password: "test"
+        expect(config.password).to eq("test")
+      end
+      it "should set password with block" do
+        config = Configuration.new do |c|
+          c.password = "password"
+        end
+        expect(config.password).to eq("password")
+      end
+    end
+
+    context "workspace" do
+      it "should return default workspace from environment variable" do
+        allow(ENV).to receive(:[]).and_return(nil)
+        allow(ENV).to receive(:[]).with("WATSON_WORKSPACE").and_return("test")
+        Configuration.new.workspace
+        expect(Configuration.new.workspace).to eq("test")
+      end
+      it "should set workspace" do
+        config = Configuration.new
+        config.workspace = "test"
+        expect(config.workspace).to eq("test")
+      end
+      it "should set workspace with argument" do
+        config = Configuration.new workspace: "test"
+        expect(config.workspace).to eq("test")
+      end
+      it "should set workspace with block" do
+        config = Configuration.new do |c|
+          c.workspace = "workspace"
+        end
+        expect(config.workspace).to eq("workspace")
+      end
+    end
+
+    context "version" do
+      it "should return default version from environment variable" do
+        allow(ENV).to receive(:[]).and_return(nil)
+        allow(ENV).to receive(:[]).with("WATSON_WORKSPACE_VERSION").and_return("test")
+        Configuration.new.version
+        expect(Configuration.new.version).to eq("test")
+      end
+      it "should set version" do
+        config = Configuration.new
+        config.version = "test"
+        expect(config.version).to eq("test")
+      end
+      it "should set version with argument" do
+        config = Configuration.new version: "test"
+        expect(config.version).to eq("test")
+      end
+      it "should set version with block" do
+        config = Configuration.new do |c|
+          c.version = "version"
+        end
+        expect(config.version).to eq("version")
+      end
+    end
+
+    context "redis_url" do
+      it "should return default redis_url from environment variable" do
+        allow(ENV).to receive(:[]).and_return(nil)
+        allow(ENV).to receive(:[]).with("REDIS_URL").and_return("test")
+        Configuration.new.redis_url
+        expect(Configuration.new.redis_url).to eq("test")
+      end
+      it "should set redis_url" do
+        config = Configuration.new
+        config.redis_url = "test"
+        expect(config.redis_url).to eq("test")
+      end
+      it "should set redis_url with argument" do
+        config = Configuration.new redis_url: "test"
+        expect(config.redis_url).to eq("test")
+      end
+      it "should set redis_url with block" do
+        config = Configuration.new do |c|
+          c.redis_url = "redis_url"
+        end
+        expect(config.redis_url).to eq("redis_url")
+      end
+    end
+
+    context "base uri" do
+      it "should return default base uri" do
+        expect(Configuration.new.base_uri.nil?).to be false
+        expect(Configuration.new.base_uri.length).to be > 0
+      end
+      it "should set base uri" do
+        config = Configuration.new
+        config.base_uri = "http://mycustom.url"
+        expect(config.base_uri).to eq("http://mycustom.url")
+      end
+      it "should set base uri with block" do
+        config = Configuration.new do |c|
+          c.base_uri = "http://mycustomapi.url"
+        end
+        expect(config.base_uri).to eq("http://mycustomapi.url")
+      end
+    end
+
+  end
+end

data/spec/fixtures/message/created.txt

@@ -0,0 +1,21 @@
+HTTP/1.1 200 OK
+X-Backside-Transport: OK OK
+Connection: Keep-Alive
+Transfer-Encoding: chunked
+X-Frame-Options: SAMEORIGIN
+Strict-Transport-Security: max-age=31536000;
+ETag: W/"1cd-XPBepDE7HNqNr6wZapZ1+w"
+X-Content-Type-Options: nosniff
+X-Download-Options: noopen
+X-DNS-Prefetch-Control: off
+Vary: Accept-Encoding
+X-XSS-Protection: 1; mode=block
+Date: Tue, 23 May 2017 10:26:14 GMT
+Content-Type: application/json;charset=utf-8
+Server: -
+Set-Cookie: Watson-DPAT=1IUyfHxFvm9UhVYgNXBRScD8lDxY2xWsK3xSpNYmKq5YY0exS%2Fqtz55Sxg9Ys6%2F7v18ofQ9%2BhmrP68PBAMHjkJ4jGENioEoqtqWnU4ts4s0D9%2FTj9dniC7UxKdUsw9eUF32Usd4UVuvSb%2BWSEETs2HoL4GTHZxxWa0jeUXgI2CDSsvPpiSypRfvQz8Jqb9naK1TA2qyWOlNxLRvmFlmhdlBGrIXsp9QhgPeEgikZK9d4MZrdZXw6ht2T%2FJo93BsGgzrUf0ForfXw2pjh6MuAIFNTFzzeTkhqTyCF1GOxFmbDCObOgLTO2tuWTpn7pAiLNUL2vsogOWlf0GEsZSh012hpxPsNj0OCigne%2FxyY5Dj9o%2FY0HXvSa17A71qlIrFoYs0kyC5YCuiWOOOMfP56Jf6Ztnu39SVEKGxHRlSiT2udAJMS4t5jm0kF%2BkP%2BhBOHSOgMJGil5x25ArJtM0YfrunF81mskUM77aYUtHE%2BosCYFIgylZ3mH%2BC6mo3eG2qe76Gj1Uu5LQSSPX1Hm5mcnEsiSISyHfSveIKlb7OaYM9kjRHHsbLjnHfy2CZv7nSBKIFQMCiQk4FrRv3meSqCGz%2BmFeKCo04Cs75%2F6ySShVDA1yhJW8LhPaHhnRtXwm0zbFT4hD4qBTbFmW%2FxXdPJcsE%2B40ltYh%2FQ5H6yIAAYykujtkHCigkTrjiIiyPmAgB9zSx7sl934Lf1XVeSsDNJS83jyqOCG804BCZN8bfhRY4%2BxvjR5zD9Rm%2Fy6Rl9n%2BNOIV9F7aV45YTvHRJ%2FEHPDb5AIl9dwqsW0nfaz43KeZ7K9F2cqgHOP7fJCmUE9Q2e%2FkoUikETdW5q5JxuxntQ6BALK%2BtfC%2FbLIJORiDKm4%2FhKtKlBPoRsdANOkpdAe7%2FjugaJWkmPQ7ayYTOfBlHCyZoYUtbSL9AJFFgaq9utrNqe5Fr0VGnQ4TV%2Fn%2BmxcXYlQSTcDGS%2F8mpm0FLDXtqxuIg%3D%3D; path=/conversation/api; secure; HttpOnly
+X-Client-IP: 220.101.98.130
+X-Global-Transaction-ID: 1468324772
+X-DP-Watson-Tran-ID: gateway-dp02-1468324772
+
+{"intents":[{"intent":"Greeting","confidence":1}],"entities":[{"entity":"Greeting","location":[0,2],"value":"Hi","confidence":1}],"input":{"text":"hi"},"output":{"log_messages":[],"text":["Hi, how are you?"],"nodes_visited":["greeting"]},"context":{"conversation_id":"d17270f6-671e-473b-b981-65761a9d5128","system":{"dialog_stack":[{"dialog_node":"greeting"}],"dialog_turn_counter":1,"dialog_request_counter":1,"_node_output_map":{"node_2_1494386292425":[0]}}}}

data/spec/fixtures/message/error.txt

@@ -0,0 +1,21 @@
+HTTP/1.1 400 Bad Request
+X-Backside-Transport: FAIL FAIL
+Connection: Keep-Alive
+Transfer-Encoding: chunked
+X-Frame-Options: SAMEORIGIN
+Strict-Transport-Security: max-age=31536000;
+ETag: W/"37-GiTifP4vb9PqzZCy57Cz7A"
+X-Content-Type-Options: nosniff
+X-Download-Options: noopen
+X-DNS-Prefetch-Control: off
+Vary: Accept-Encoding
+X-XSS-Protection: 1; mode=block
+Date: Tue, 23 May 2017 10:59:42 GMT
+Content-Type: application/json;charset=utf-8
+Server: -
+Set-Cookie: Watson-DPAT=AqqzbJRf25aUFnKhzKDjg%2Bmqhdx%2BKMTTg8I9RMzub6jsDkn6kC2ObdYFLwjUBhXglnrH47KPEBaC7dF5G62Gsh9kklkjKX4GLW5j%2BztLAh3dr4tv6jt9qN97W4URreaF99zP0fLHH%2FDvyYxTAw0VSvGpNc5%2B0kC%2FOukrM7EUDXdsgN%2FQdglfeTficysYFhaq%2FXLs6rphgcD5m7x99klh1Bh4aFjaSueecLB%2FEV8WUhb281%2FZIRFKgVE%2F2IB3V8PV3D1oXtTIjJHeumVRc7JGIHcXy%2Ba0DI%2BFAr8zI0mSKz7LqB%2Fq8OWikXssLZW3Noojlq9FX1hNYIMxOup583aeptDJhpSe%2BIV2rCrqAYafVy8s2%2BcLovB3WdHPFmE35cAmm%2BokC1PU4CMXoslsDk5sN97CfwVXaFJdKg1cviKFcw6hwX0aHTauNof8kbXC2aGStG%2F0e8nkXFs2bFAhANJ8u88x57i5ciS8fnry5ZwZZiFxs4qTbOKADuoV3r96ClrwAtodeLdMYJCClMFENb4IMqnMmhgOo8sjHCoDqJH8LHJEVCxxSlgJrb4wcCtVAEJDeVxejl2v5dokRakBWvdG%2BwOvVcgR41LzQ6n8Xj%2BtQ2HfUsfzaHT33KsoXHYFHTcC8elzq5R0z8G6WrGZMAaAtxwwsaGGaKbVKyruGRP0AyYI2QwW9%2FWYUzzXHoTt6r9cQBbru72gyIVDQwGanMSLt6h3QDwXDsTb4I5JVB0E9T3sR1fUt1SEivUBZqipCvgctp%2BbVAKbnZNr4OjDOxL0VbS2WiCvr6p3RGi39KXfH500xUpWJXtcPNi8xLtNjKEVnoancJYZmC20p6WYqnEJAHva4BgkxrDZOsAsxS4XvVSzcyYtxOnBceCsOvMVtt2xYhF68OrShMp9VAJkd75qYoJTHGJQ5BW%2FysMY4djh5xdrtsI4EvvwzvHHLQezcOp2P0d57h%2BqhUY%3D; path=/conversation/api; secure; HttpOnly
+X-Client-IP: 220.101.98.130
+X-Global-Transaction-ID: 1437918292
+X-DP-Watson-Tran-ID: gateway-dp01-1437918292
+
+{"error":{"error":"Missing 'version' query parameter"}}

data/spec/helpers.rb

@@ -0,0 +1,20 @@
+
+def spec_dir
+  File.join Watsbot.root, "spec"
+end
+
+def fixture_dir
+  File.join spec_dir, "fixtures"
+end
+
+def watson_uri(path)
+  Watsbot::BASE_URI + path
+end
+
+def watson_ruri(path)
+  %r{#{watson_uri(path)}}
+end
+
+def fixture_path(file)
+  File.new File.join(fixture_dir, file)
+end

data/spec/message_spec.rb

@@ -0,0 +1,65 @@
+require "spec_helper"
+
+module Watsbot
+  RSpec.describe Message do
+
+    let(:valid_config) {
+      Watsbot::Configuration.new(
+        username:  ENV["WATSON_USERNAME"],
+        password:  ENV["WATSON_PASSWORD"],
+        workspace: ENV["WATSON_WORKSPACE"],
+        version:   ENV["WATSON_WORKSPACE_VERSION"],
+        redis_url: ENV["REDIS_URL"]
+        )
+    }
+
+    describe "#send" do
+      context "invalid" do
+        it "raises error - no uid" do
+          message = Watsbot::Message.new(valid_config)
+          expect { message.send(nil, "Hi", {}) }.to raise_error("uid should be provided")
+        end
+        it "raises error - no message" do
+          message = Watsbot::Message.new(valid_config)
+          uid = SecureRandom.uuid
+          expect { message.send(uid, nil, {}) }.to raise_error("message should be provided")
+        end
+        it "raises error - blank uid" do
+          message = Watsbot::Message.new(valid_config)
+          expect { message.send('', "Hi", {}) }.to raise_error("uid should be provided")
+        end
+        it "raises error - blank message" do
+          message = Watsbot::Message.new(valid_config)
+          uid = SecureRandom.uuid
+          expect { message.send(uid, '', {}) }.to raise_error("message should be provided")
+        end
+        it "responds with error state - no version" do
+          stub_request(:post, watson_uri("/workspaces/#{Watsbot.configuration.workspace}/message?version=")).to_return(fixture_path("message/error.txt"))
+          message = Watsbot::Message.new(valid_config)
+          uid = SecureRandom.uuid
+          Watsbot.configuration.version = nil
+          response = message.send(uid, "Hi", {})
+          expect(response.class).to eq(Response::Error)
+          Watsbot.configuration.version = ENV['WATSON_WORKSPACE_VERSION']
+        end
+      end
+      context "valid" do
+        it "responds with success state" do
+          stub_request(:post, watson_uri("/workspaces/#{Watsbot.configuration.workspace}/message?version=#{Watsbot.configuration.version}")).to_return(fixture_path("message/created.txt"))
+          message = Watsbot::Message.new(valid_config)
+          uid = SecureRandom.uuid
+          response = message.send(uid, "Hi", {})
+          expect(response.class).to eq(Response::Success)
+        end
+        it "stores the context" do
+          stub_request(:post, watson_uri("/workspaces/#{Watsbot.configuration.workspace}/message?version=#{Watsbot.configuration.version}")).to_return(fixture_path("message/created.txt"))
+          message = Watsbot::Message.new(valid_config)
+          uid = SecureRandom.uuid
+          message.send(uid, "Hi", {})
+          expect(State.instance.fetch(uid)).not_to eq(nil)
+        end
+      end
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,21 @@
+require "bundler/setup"
+require "watsbot"
+require "pry"
+require "simplecov"
+require "webmock/rspec"
+require "byebug"
+require "helpers"
+require "securerandom"
+require "dotenv"
+
+Dotenv.load
+WebMock.enable!
+SimpleCov.start
+
+RSpec.configure do |config|
+  config.example_status_persistence_file_path = ".rspec_status"
+  config.disable_monkey_patching!
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end

data/spec/state_spec.rb

@@ -0,0 +1,67 @@
+require "spec_helper"
+
+module Watsbot
+  RSpec.describe State do
+
+    describe "#fetch" do
+      it "returns nil" do
+        state = State.instance
+        uid = SecureRandom.uuid
+        expect(state.fetch(uid)).to be(nil)
+      end
+      it "returns data" do
+        state = State.instance
+        uid = SecureRandom.uuid
+        data = { data: {} }
+        state.store(uid, data.to_json)
+        expect(state.fetch(uid)).to eq(data.to_json)
+      end
+    end
+
+    describe "#store" do
+      it "returns data" do
+        state = State.instance
+        uid = SecureRandom.uuid
+        expect(state.fetch(uid)).to eq(nil)
+      end
+      it "returns data" do
+        state = State.instance
+        uid = SecureRandom.uuid
+        data = { data: {} }
+        state.store(uid, data.to_json)
+        expect(state.fetch(uid)).to eq(data.to_json)
+      end
+    end
+
+    describe "#exists?" do
+      it "returns data" do
+        state = State.instance
+        uid = SecureRandom.uuid
+        expect(state.exists?(uid)).to eq(false)
+      end
+      it "returns data" do
+        state = State.instance
+        uid = SecureRandom.uuid
+        data = { data: {} }
+        state.store(uid, data.to_json)
+        expect(state.exists?(uid)).to eq(true)
+      end
+    end
+
+    describe "#delete" do
+      it "returns data" do
+        state = State.instance
+        uid = SecureRandom.uuid
+        expect(state.delete(uid)).to eq(0)
+      end
+      it "returns data" do
+        state = State.instance
+        uid = SecureRandom.uuid
+        data = { data: {} }
+        state.store(uid, data.to_json)
+        expect(state.delete(uid)).to eq(1)
+      end
+    end
+
+  end
+end