flowthings 0.1.1

data/spec/flowthings_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe Flowthings do
+  it 'has a version number' do
+    expect(Flowthings::VERSION).not_to be nil
+  end
+end

data/spec/platform_object_interface_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Flowthings::PlatformObjectInterface do
+  describe "platform object" do
+    before do
+      @connection = {}
+    end
+    it "should raise an error if you try to initialize it" do
+      expect { Flowthings::PlatformObjectInterface.new @connection }.to raise_error(Flowthings::Error::ObjectError, "Use the actual platform objects")
+    end
+  end
+end

data/spec/platform_objects/api_task_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+
+describe Flowthings::ApiTask do
+
+  before do
+    @account_name = ENV["FT_ACCOUNT_NAME"]
+    @account_token = ENV["FT_ACCOUNT_TOKEN"]
+
+    @api = Flowthings::Client.new({account_name: @account_name,
+                                   account_token: @account_token})
+  end
+
+  describe ".create, .read, .update, .destroy" do
+
+    before(:example) do
+      @path = "/" + @account_name + "/ruby-client-test"
+      @flow = @api.flow.create({"path" => @path,
+                                "description" => "description"})
+
+      @flowId = @flow["id"]
+
+      @api_task_task = {
+        "destination" => @path,
+        "periodicity" => 120000,
+        "js" => "new Task({
+          request: {uri: 'http://api.example.com/data.json', method: 'GET'},
+          callback: function(responseText) {
+          var json = JSON.parse(responseText);
+            return json['items'].map(function(item) {
+              return {
+                elems: {
+                  title : {type: 'string', value: item.title},
+                  source_uri : {type: 'uri', value: item.uri}
+                }
+              }
+            });"
+      }
+
+      @api_task_task_updated = {
+        "destination" => @path,
+        "periodicity" => 120000,
+        "js" => "new Task({
+          request: {uri: 'http://api.example.com/data.json', method: 'GET'},
+          callback: function(responseText) {
+          var json = JSON.parse(responseText);
+            return json['items'].map(function(item) {
+              return {
+                elems: {
+                  title : {type: 'string', value: item.title},
+                  source_uri : {type: 'uri', value: item.uri}
+                }
+              }
+            });",
+        "displayName" => "testtesttest"
+      }
+
+    end
+
+    after(:example) do
+      @api.flow.delete(@flowId)
+    end
+
+
+    it "should do all of these operations correctly" do
+
+      api_task_response = @api.api_task.create(@api_task_task)
+
+      expect(api_task_response.empty?).not_to be true
+
+      expect(api_task_response["destination"]).to eq(@path)
+      expect(api_task_response["periodicity"]).to eq(@api_task_task["periodicity"])
+      expect(api_task_response["js"]).to eq(@api_task_task["js"])
+
+      read_response = @api.api_task.read(api_task_response["id"])
+
+      expect(read_response["id"]).to eq(api_task_response["id"])
+
+      update_response = @api.api_task.update(api_task_response["id"],
+                                                  @api_task_task_updated)
+
+
+      expect(update_response["displayName"]).to eq(@api_task_task_updated["displayName"])
+
+      delete_response = @api.api_task.delete(api_task_response["id"])
+
+      expect(delete_response.empty?).to be true
+    end
+
+  end
+
+
+end

data/spec/platform_objects/drop_spec.rb

@@ -0,0 +1,180 @@
+require 'spec_helper'
+
+describe Flowthings::Drop do
+  before do
+    @account_name = ENV["FT_ACCOUNT_NAME"]
+    @account_token = ENV["FT_ACCOUNT_TOKEN"]
+
+    @api = Flowthings::Client.new account_name: @account_name, account_token: @account_token
+
+    # @flow = @api.flow.create({"path" => "/greg/test/ruby"})
+  end
+
+  # after do
+  #   # @flow = @api.flow.create({"path" => "/greg/test/ruby"})
+  # end
+
+
+  describe ".get" do
+    it "should get the proper information from the platform" do
+      api = Flowthings::Client.new({account_name: "greg",
+                                     account_token: "p2lAhiLuQeqWN0EMeClmTAYPjgPy"})
+
+      result = {
+        "id" => "d551720070cf25d405fb1e495",
+        "flowId" => "f55171ff90cf2ece6103ef410",
+        "creationDate" => 1427578887233,
+        "path" => "/greg/test/ruby-drop",
+        "version" => 0,
+        "elems" => {
+          "drop" => {
+            "type" => "string",
+            "value" => "adsf"
+          }
+        }
+      }
+
+      drop = api.drop("f55171ff90cf2ece6103ef410").read("d551720070cf25d405fb1e495")
+
+      expect(drop).to eq(result)
+    end
+  end
+
+  describe ".create, .update, .destroy" do
+
+    before(:example) do
+      @path = "/" + @account_name + "/ruby-client-test"
+      @flow = @api.flow.create "path" => @path, "description" => "description"
+
+      @flowId = @flow["id"]
+
+      @drop = {"elems" => {
+                 "elem_name" => {
+                   "type" => "string",
+                   "value" => "elem_value"
+                 }
+               }
+              }
+
+      @update_drop = {"elems" => {
+                        "elem_name" => {
+                          "type" => "string",
+                          "value" => "elem_value"
+                        },
+                        "second_elem" => {
+                          "type" => "string",
+                          "value" => "elem_value"
+                        }
+                      }
+                     }
+
+      @aggregation = {
+        "filter": "EXISTS elem_name",
+        "output": ["$count"]
+      }
+    end
+
+    after(:example) do
+      @api.flow.delete @flowId
+    end
+
+    it "should create, update and then delete a drop on the platform" do
+      create_response = @api.drop(@flowId).create @drop
+      dropId = create_response["id"]
+
+      update_response = @api.drop(@flowId).update dropId, @update_drop
+
+      destroy_response = @api.drop(@flowId).destroy dropId
+
+      expect(create_response.empty?).not_to be true
+      expect(create_response["flowId"]).to eq(@flowId)
+      expect(create_response["elems"]).to eq(@drop["elems"])
+
+      expect(update_response.empty?).not_to be true
+      expect(update_response["flowId"]).to eq(@flowId)
+      expect(update_response["id"]).to eq(dropId)
+      expect(update_response["elems"]).to eq(@update_drop["elems"])
+
+      expect(destroy_response.empty?).to be true
+    end
+
+  end
+
+  describe ".aggregate" do
+    before(:example) do
+      @path = "/" + @account_name + "/ruby-client-test"
+      @flow = @api.flow.create({"path" => @path,
+                                "description" => "description"})
+
+      @flowId = @flow["id"]
+
+      @drop = {"elems" => {
+                 "elem_name" => {
+                   "type" => "string",
+                   "value" => "elem_value"
+                 }
+               }
+              }
+
+      @api.drop(@flowId).create(@drop)
+
+      @aggregation = {
+        "filter": "EXISTS elem_name",
+        "output": ["$count"]
+      }
+    end
+
+    after(:example) do
+      @api.flow.delete(@flowId)
+    end
+
+    it "should aggregate properly" do
+      aggregate_response = @api.drop(@flowId).aggregate(@aggregation)
+
+      expect(aggregate_response.class).to be Array
+      expect(aggregate_response[0]["$count"]).to eq(1)
+    end
+
+  end
+
+
+  describe "error" do
+
+    before(:example) do
+      path = "/" + @account_name + "/ruby-client-test"
+
+      @flow = @api.flow.create({"path" => path,
+                                "description" => "description"})
+
+      @flowId = @flow["id"]
+      @api.flow.destroy(@flowId)
+
+      @drop = {"elems" => {
+                 "elem_name" => {
+                   "type" => "string",
+                   "value" => "elem_value"
+                 }
+               }
+              }
+    end
+
+    it "should error when appropriate" do
+      expect {
+        @api.drop(@flowId).create(@drop)
+      }.to raise_error
+    end
+
+    it "should be able to rescue from an error" do
+      expect {
+        begin
+          @api.drop(@flowId).create(@drop)
+        rescue Flowthings::Error::BadRequest => e
+          error = e
+        end
+
+      }.not_to raise_error
+    end
+
+  end
+
+end

data/spec/platform_objects/flow_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+describe Flowthings::Flow do
+  before do
+    @flowid = "f55171ff90cf2ece6103ef410"
+
+    @account_name = ENV["FT_ACCOUNT_NAME"]
+    @account_token = ENV["FT_ACCOUNT_TOKEN"]
+    @api = Flowthings::Client.new({account_name: @account_name,
+                                   account_token: @account_token})
+  end
+
+  describe ".read" do
+    it "should get the proper information from the platform" do
+      api = Flowthings::Client.new({account_name: 'greg',
+                                     account_token: "p2lAhiLuQeqWN0EMeClmTAYPjgPy"})
+
+      response = {"id" => "f55171ff90cf2ece6103ef410",
+                  "capacity" => 1000,
+                  "creationDate" => 1427578873318,
+                  "creatorId" => "i54af263c0cf25b8ea459c204",
+                  "path" => "/greg/test/ruby-drop"}
+
+
+      expect(api.flow.read(@flowid)).to eq(response)
+    end
+  end
+
+
+  describe ".create, .update, .delete" do
+    it "should create, update and then delete a flow properly" do
+      response = {}
+
+      path = "/" + @account_name + "/ruby-client-test"
+
+      expect{
+        response = @api.flow.create({"path" => path,
+                                     "description" => "description",
+                                     "filter" => "EXISTS title"})
+      }.not_to raise_error
+
+      expect(response.empty?).not_to be true
+      expect(response["path"]).to eq(path)
+      expect(response["description"]).to eq("description")
+      expect(response["filter"]).to eq("EXISTS title")
+
+      updated_response = @api.flow.update(response["id"], {"path" => path,
+                                                           "description" => "description",
+                                                           "filter" => ""})
+      @id = response["id"]
+
+      expect(updated_response["id"]).to eq(response["id"])
+      expect(updated_response["description"]).to eq("description")
+      expect(updated_response["path"]).to eq(path)
+
+      expect(updated_response["filter"].empty?).to be true
+
+      expect(@api.flow.destroy(response["id"]).empty?).to be true
+    end
+  end
+
+  describe ".find" do
+    before do
+      path = "/" + @account_name + "/ruby-client-test"
+      @flow = @api.flow.create({"path" => path,
+                                "description" => "description",
+                                "filter" => "EXISTS title"})
+    end
+
+    after do
+      @api.flow.destroy(@flow["id"])
+    end
+
+    it "should find the correct flow" do
+      path_regex = "/\\/" + @account_name + "\\/ruby-client-test/"
+
+      flow = @api.flow.find(filter: "path =~ " + path_regex)
+      expect(flow[0] == @flow)
+    end
+
+  end
+
+end

data/spec/platform_objects/platform_objects_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+require 'active_support/inflector'
+
+platform_objects = [Flowthings::ApiTask, Flowthings::Drop, Flowthings::Flow, Flowthings::Group, Flowthings::Identity, Flowthings::Mqtt, Flowthings::Share, Flowthings::Token, Flowthings::Track]
+crud_methods = ["create", "read", "update", "destroy"]
+
+
+platform_objects.each do |platform_object|
+
+  describe platform_object do
+
+    before do
+      @options = {}
+      @flowId = "f123456"
+      @connection = {}
+    end
+
+    describe "initialization" do
+      it "should error out without any arguments" do
+        expect { platform_object.new }.to raise_error(ArgumentError)
+      end
+
+      unless platform_object == Flowthings::Drop
+        it "should take a connection argument and an options argument" do
+          expect { platform_object.new @connection, @options }.not_to raise_error
+        end
+        it "the options argument should be optional" do
+          expect { platform_object.new @connection }.not_to raise_error
+        end
+      else
+        it "should take an options argument, a flowId and a connection" do
+          expect { platform_object.new @flowId, @connection, @options }.not_to raise_error
+        end
+
+        it "should error out with only one argument" do
+          expect { platform_object.new @flowId }.to raise_error(ArgumentError)
+        end
+
+        it "should have an optional options argument" do
+          expect { platform_object.new @flowId, @connection }.not_to raise_error
+        end
+      end
+
+    end #init
+
+    describe "crud" do
+      before do
+        unless platform_object == Flowthings::Drop
+          @initialized_object = platform_object.new @options
+        else
+          @initialized_object = platform_object.new @flowId, @options
+        end
+      end
+
+      crud_methods.each do |method|
+        describe ".#{method}" do
+          unless method == "update"&& ( platform_object == Flowthings::Share || platform_object == Flowthings::Token )
+            it "should respond to the method" do
+              expect(@initialized_object.respond_to? "#{method}").to be true
+            end
+          else
+            it "should not respond to the method" do
+              expect(@initialized_object.respond_to? "#{method}").to be false
+            end
+          end
+        end
+
+      end
+
+    end
+  end
+
+end

data/spec/platform_objects/track_spec.rb

@@ -0,0 +1,46 @@
+require "spec_helper"
+
+describe Flowthings::Track do
+  before(:example) do
+    @account_name = ENV["FT_ACCOUNT_NAME"]
+    @account_token = ENV["FT_ACCOUNT_TOKEN"]
+
+    @api = Flowthings::Client.new({
+                                    account_name: @account_name,
+                                    account_token: @account_token
+                                  })
+  end
+
+  describe ".simulate" do
+    it "should simulate track output" do
+
+      simulated_track = {
+        "drop" => {
+          "elems" => {
+            "a" => 1
+          }
+        },
+        "js" => "function (input_drop) {
+              var a = input_drop.elems.a.value;
+              input_drop.elems.b = a  * 3;
+              return input_drop;
+            }"
+      }
+
+
+      track_response = @api.track.simulate(simulated_track)
+
+      expect(track_response.empty?).not_to be true
+
+      drops = track_response["drops"]
+      log = track_response["log"]
+      errs = track_response["errors"]
+
+      expect(errs.empty?).to be true
+      expect(drops.empty?).not_to be true
+      expect(log.empty?).not_to be true
+
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+require 'dotenv'
+Dotenv.load
+
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'flowthings'

metadata

@@ -0,0 +1,192 @@
+--- !ruby/object:Gem::Specification
+name: flowthings
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Greg Meyer
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-07-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+- !ruby/object:Gem::Dependency
+  name: excon
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.44'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.44'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.12'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.5'
+description: flowthings.io is an agile intelligence platform that is specifically
+  geared towards the Internet of Things. This is our Ruby Client.
+email:
+- dev@flowthings.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- Guardfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- flowthings.gemspec
+- lib/flowthings.rb
+- lib/flowthings/client.rb
+- lib/flowthings/configuration.rb
+- lib/flowthings/connection.rb
+- lib/flowthings/crud/aggregate.rb
+- lib/flowthings/crud/base.rb
+- lib/flowthings/crud/extended_methods.rb
+- lib/flowthings/crud/find.rb
+- lib/flowthings/crud/member_update.rb
+- lib/flowthings/crud/simulate.rb
+- lib/flowthings/error.rb
+- lib/flowthings/platform_objects/api_task.rb
+- lib/flowthings/platform_objects/drop.rb
+- lib/flowthings/platform_objects/flow.rb
+- lib/flowthings/platform_objects/group.rb
+- lib/flowthings/platform_objects/identity.rb
+- lib/flowthings/platform_objects/mqtt.rb
+- lib/flowthings/platform_objects/platform_object_interface.rb
+- lib/flowthings/platform_objects/share.rb
+- lib/flowthings/platform_objects/token.rb
+- lib/flowthings/platform_objects/track.rb
+- lib/flowthings/request.rb
+- lib/flowthings/response/platform_response.rb
+- lib/flowthings/response/raise_errors.rb
+- lib/flowthings/utils/crud_utils.rb
+- lib/flowthings/utils/member.rb
+- lib/flowthings/version.rb
+- spec/client_configuration_spec.rb
+- spec/client_spec.rb
+- spec/configuration_spec.rb
+- spec/flowthings_spec.rb
+- spec/platform_object_interface_spec.rb
+- spec/platform_objects/api_task_spec.rb
+- spec/platform_objects/drop_spec.rb
+- spec/platform_objects/flow_spec.rb
+- spec/platform_objects/platform_objects_spec.rb
+- spec/platform_objects/track_spec.rb
+- spec/spec_helper.rb
+homepage: https://flowthings.io
+licenses:
+- Apache 2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: A rubygem for the flowthings.io platform.
+test_files: []