cosm-rb 0.0.1

data/spec/support/fully_represent_datapoint_matcher.rb

@@ -0,0 +1,30 @@
+RSpec::Matchers.define :fully_represent_datapoint do |format, formatted_datapoint|
+  match do |datapoint|
+    if format.to_sym == :xml
+      match_xml_datapoint(datapoint, formatted_datapoint)
+    end
+  end
+
+  failure_message_for_should do |datapoint|
+    "expected #{datapoint} to fully represent #{formatted_datapoint}"
+  end
+
+  description do
+    "expected #{formatted_datapoint.class} to be fully represented"
+  end
+
+  def match_xml_datapoint(datapoint, formatted_datapoint)
+    xml = Nokogiri.parse(formatted_datapoint)
+    case xml.root.attributes["version"].value
+    when "0.5.1"
+      environment = xml.at_xpath("//xmlns:environment")
+      data = environment.at_xpath("xmlns:data")
+      datapoint.value.should == data.at_xpath("xmlns:datapoints").at_xpath("xmlns:value").content
+      datapoint.at.should == data.at_xpath("xmlns:datapoints").at_xpath("xmlns:value").attributes["at"].value
+    else
+      false
+    end
+  end
+end
+
+

data/spec/support/fully_represent_datastream_matcher.rb

@@ -0,0 +1,92 @@
+RSpec::Matchers.define :fully_represent_datastream do |format, formatted_datastream|
+  match do |datastream|
+    case format.to_sym
+    when :xml
+      match_xml_datastream(datastream, formatted_datastream)
+    when :json
+      match_json_datastream(datastream, formatted_datastream)
+    when :csv
+      match_csv_datastream(datastream, formatted_datastream)
+    else
+      raise "Unknown Datastream format: '#{format}'"
+    end
+  end
+
+  failure_message_for_should do |datastream|
+    "expected #{datastream} to fully represent #{formatted_datastream}"
+  end
+
+  description do
+    "expected #{formatted_datastream.class} to be fully represented"
+  end
+
+  def match_xml_datastream(datastream, formatted_datastream)
+    xml = Nokogiri.parse(formatted_datastream)
+    case xml.root.attributes["version"].value
+    when "0.5.1"
+      environment = xml.at_xpath("//xmlns:environment")
+      data = environment.at_xpath("xmlns:data")
+      datastream.feed_id.should == environment.attributes["id"].value
+      datastream.feed_creator.should == environment.attributes["creator"].value
+      datastream.id.should == data.attributes["id"].value
+      if (tags = data.xpath("xmlns:tag")).any?
+        datastream.tags.should == tags.map(&:content).sort{|a,b| a.downcase<=>b.downcase}.join(',')
+      end
+      current_value = data.at_xpath("xmlns:current_value")
+      datastream.current_value.should == current_value.content
+      datastream.updated.should == current_value.attributes["at"].value if current_value.attributes["at"]
+      datastream.min_value.should == data.at_xpath("xmlns:min_value").content
+      datastream.max_value.should == data.at_xpath("xmlns:max_value").content
+      unit = data.at_xpath("xmlns:unit")
+      if unit
+        datastream.unit_label.should == unit.content
+        datastream.unit_type.should == unit.attributes["type"].value if unit.attributes["type"]
+        datastream.unit_symbol.should == unit.attributes["symbol"].value if unit.attributes["symbol"]
+      end
+      datastream.datapoints.each do |point|
+        dp = data.at_xpath("xmlns:datapoints").at_xpath("xmlns:value[@at=\"#{point.at}\"]")
+        point.value.should == dp.content
+      end
+      true
+    when "5"
+      environment = xml.at_xpath("//xmlns:environment")
+      data = environment.at_xpath("xmlns:data")
+      datastream.feed_id.should == environment.attributes["id"].value
+      datastream.feed_creator.should == "http://www.haque.co.uk"
+      datastream.id.should == data.attributes["id"].value
+      if (tags = data.xpath("xmlns:tag")).any?
+        datastream.tags.should == tags.map(&:content).sort{|a,b| a.downcase<=>b.downcase}.join(',')
+      end
+      current_value = data.at_xpath("xmlns:value")
+      datastream.current_value.should == current_value.content
+      datastream.updated.should == xml.at_xpath("//xmlns:environment").attributes["updated"].value if xml.at_xpath("//xmlns:environment").attributes["updated"]
+      datastream.min_value.should == current_value.attributes["minValue"].value if current_value.attributes["minValue"]
+      datastream.max_value.should == current_value.attributes["maxValue"].value if current_value.attributes["maxValue"]
+      unit = data.at_xpath("xmlns:unit")
+      if unit
+        datastream.unit_label.should == unit.content
+        datastream.unit_type.should == unit.attributes["type"].value if unit.attributes["type"]
+        datastream.unit_symbol.should == unit.attributes["symbol"].value if unit.attributes["symbol"]
+      end
+      true
+    else
+      false
+    end
+  end
+
+  def match_json_datastream(datastream, formatted_datastream)
+    json = JSON.parse(formatted_datastream)
+    case json['version']
+    when '1.0.0'
+      raise "Not implemented"
+    else
+      false
+    end
+  end
+
+  def match_csv_datastream(datastream, formatted_datastream)
+    datastream.current_value.to_s.should == formatted_datastream.strip
+  end
+end
+
+

data/spec/support/fully_represent_feed_matcher.rb

@@ -0,0 +1,226 @@
+RSpec::Matchers.define :fully_represent_feed do |format, formatted_feed|
+  match do |feed|
+    if format.to_sym == :xml
+      match_xml_feed(feed, formatted_feed)
+    elsif format.to_sym == :json
+      match_json_feed(feed, formatted_feed)
+    elsif format.to_sym == :csv_v2
+      match_csv_v2_feed(feed, formatted_feed)
+    elsif format.to_sym == :csv_v1
+      match_csv_v1_feed(feed, formatted_feed)
+    else
+      raise "No matcher for #{format}"
+    end
+  end
+
+  failure_message_for_should do |feed|
+    "expected #{feed} to fully represent #{formatted_feed}"
+  end
+
+  description do
+    "expected #{formatted_feed.class} to be fully represented"
+  end
+
+  def match_csv_v1_feed(feed, formatted_feed)
+    csv = CSV.parse(formatted_feed.strip)
+    csv.length.should == 1
+    csv = csv.first
+    feed.datastreams.length.should == csv.length
+    feed.datastreams.each_with_index do |datastream, stream_id|
+      csv.detect {|d| d == datastream.current_value}.should_not be_nil
+      datastream.id.should == stream_id.to_s
+    end
+  end
+
+  def match_csv_v2_feed(feed, formatted_feed)
+    csv = CSV.parse(formatted_feed.strip)
+    feed.datastreams.length.should == csv.length
+    feed.datastreams.each do |datastream|
+      row = csv.detect {|d| d.first == datastream.id}
+      datastream.current_value.should == row.last
+    end
+  end
+
+  def match_xml_feed(feed, formatted_feed)
+    xml = Nokogiri.parse(formatted_feed)
+    case xml.root.attributes["version"].value
+    when "0.5.1"
+      environment = xml.at_xpath("//xmlns:environment")
+      feed.title.should == environment.at_xpath("xmlns:title").content
+      feed.updated.should == environment.attributes["updated"].value
+      feed.created.should == environment.attributes["created"].value
+      feed.creator.should == environment.attributes["creator"].value
+      feed.feed.should == environment.at_xpath("xmlns:feed").content
+      if auto_feed_url = environment.at_xpath("xmlns:auto_feed_url")
+        feed.auto_feed_url.should == auto_feed_url.content
+      end
+      feed.status.should == environment.at_xpath("xmlns:status").content
+      feed.description.should == environment.at_xpath("xmlns:description").content
+      feed.icon.should == environment.at_xpath("xmlns:icon").content
+      feed.website.should == environment.at_xpath("xmlns:website").content
+      feed.email.should == environment.at_xpath("xmlns:email").content
+      feed.private.should == environment.at_xpath("xmlns:private").content
+      feed.tags.should == environment.xpath("xmlns:tag").map(&:content).sort{|a,b| a.downcase<=>b.downcase}.join(',')
+      owner = environment.at_xpath("xmlns:user")
+      if owner
+        feed.owner_login.should == owner.at_xpath("xmlns:login").content
+      end
+      location = environment.at_xpath("xmlns:location")
+      if location
+        feed.location_name.should == location.at_xpath("xmlns:name").content
+        feed.location_lat.should == location.at_xpath("xmlns:lat").content
+        feed.location_lon.should == location.at_xpath("xmlns:lon").content
+        feed.location_ele.should == location.at_xpath("xmlns:ele").content
+        feed.location_domain.should == location.attributes["domain"].value
+        feed.location_exposure.should == location.attributes["exposure"].value
+        feed.location_disposition.should == location.attributes["disposition"].value
+      end
+      feed.datastreams.each do |ds|
+        data = environment.at_xpath("xmlns:data[@id=\"#{ds.id}\"]")
+        ds.id.should == data.attributes["id"].value
+        ds.tags.should == data.xpath("xmlns:tag").map(&:content).sort{|a,b| a.downcase<=>b.downcase}.join(',')
+        current_value = data.at_xpath("xmlns:current_value")
+        ds.current_value.should == current_value.content
+        ds.updated.should == current_value.attributes["at"].value
+        ds.min_value.should == data.at_xpath("xmlns:min_value").content
+        ds.max_value.should == data.at_xpath("xmlns:max_value").content
+        unit = data.at_xpath("xmlns:unit")
+        if unit
+          ds.unit_label.should == unit.content
+          ds.unit_type.should == unit.attributes["type"].value if unit.attributes["type"]
+          ds.unit_symbol.should == unit.attributes["symbol"].value if unit.attributes["symbol"]
+        end
+        ds.datapoints.each do |point|
+          dp = data.at_xpath("xmlns:datapoints").at_xpath("xmlns:value[@at=\"#{point.at}\"]")
+          point.value.should == dp.content
+        end
+      end
+      true
+    when "5"
+      environment = xml.at_xpath("//xmlns:environment")
+      feed.title.should == environment.at_xpath("xmlns:title").content
+      feed.updated.should == environment.attributes["updated"].value
+      feed.creator.should == "http://www.haque.co.uk"
+      feed.feed.should == environment.at_xpath("xmlns:feed").content
+      feed.status.should == environment.at_xpath("xmlns:status").content
+      feed.description.should == environment.at_xpath("xmlns:description").content
+      feed.icon.should == environment.at_xpath("xmlns:icon").content
+      feed.website.should == environment.at_xpath("xmlns:website").content
+      feed.email.should == environment.at_xpath("xmlns:email").content
+      location = environment.at_xpath("xmlns:location")
+      if location
+        feed.location_name.should == location.at_xpath("xmlns:name").content
+        feed.location_lat.should == location.at_xpath("xmlns:lat").content
+        feed.location_lon.should == location.at_xpath("xmlns:lon").content
+        feed.location_ele.should == location.at_xpath("xmlns:ele").content
+        feed.location_domain.should == location.attributes["domain"].value
+        feed.location_exposure.should == location.attributes["exposure"].value
+        feed.location_disposition.should == location.attributes["disposition"].value
+      end
+      feed.datastreams.each do |ds|
+        data = environment.at_xpath("xmlns:data[@id=\"#{ds.id}\"]")
+        ds.id.should == data.attributes["id"].value
+        ds.tags.should == data.xpath("xmlns:tag").map(&:content).sort{|a,b| a.downcase<=>b.downcase}.join(',')
+        current_value = data.at_xpath("xmlns:value")
+        ds.current_value.should == current_value.content
+        ds.updated.should == environment.attributes["updated"].value
+        ds.min_value.should == current_value.attributes["minValue"].value
+        ds.max_value.should == current_value.attributes["maxValue"].value
+        unit = data.at_xpath("xmlns:unit")
+        if unit
+          ds.unit_label.should == unit.content
+          ds.unit_type.should == unit.attributes["type"].value if unit.attributes["type"]
+          ds.unit_symbol.should == unit.attributes["symbol"].value if unit.attributes["symbol"]
+        end
+      end
+      true
+    else
+      false
+    end
+  end
+
+  def match_json_feed(feed, formatted_feed)
+    json = JSON.parse(formatted_feed)
+    case json['version']
+    when '1.0.0'
+      feed.title.should == json["title"]
+      feed.status.should == json["status"]
+      feed.creator.should == json["creator"]
+      feed.updated.should == json["updated"]
+      feed.created.should == json["created"]
+      feed.website.should == json["website"]
+      feed.private.should == json["private"]
+      feed.feed.should == json["feed"]
+      feed.auto_feed_url.should == json["auto_feed_url"]
+      no_units = true
+      feed.datastreams.should_not be_empty
+      feed.datastreams.each do |datastream|
+        ds = json['datastreams'].detect{|s| s["id"] == datastream.id}
+        datastream.current_value.should == ds["current_value"]
+        datastream.min_value.should == ds["min_value"]
+        datastream.max_value.should == ds["max_value"]
+        datastream.updated.should == ds["at"]
+        datastream.tags.should == ds["tags"].join(',')
+        if ds["unit"]
+          no_units = false
+          datastream.unit_label.should == ds["unit"]["label"]
+          datastream.unit_symbol.should == ds["unit"]["symbol"]
+          datastream.unit_type.should == ds["unit"]["type"]
+        end
+        datastream.datapoints.each do |datapoint|
+          dp = ds['datapoints'].detect{|s| s["at"] == datapoint.at}
+          datapoint.value.should == dp["value"]
+        end
+      end
+      raise "This test is testing a feed with no datastream units" if no_units
+      feed.id.should == json["id"]
+      json["location"].should_not be_empty
+      feed.location_disposition.should == json["location"]["disposition"]
+      feed.location_domain.should == json["location"]["domain"]
+      feed.location_ele.should == json["location"]["ele"]
+      feed.location_exposure.should == json["location"]["exposure"]
+      feed.location_lat.should == json["location"]["lat"]
+      feed.location_lon.should == json["location"]["lon"]
+      feed.location_name.should == json["location"]["name"]
+      feed.owner_login.should == json["user"]["login"]
+    when '0.6-alpha'
+      feed.title.should == json["title"]
+      feed.status.should == json["status"]
+      feed.updated.should == json["updated"]
+      feed.website.should == json["website"]
+      feed.private.should be_nil
+      feed.feed.should == json["feed"]
+      no_units = true
+      feed.datastreams.should_not be_empty
+      feed.datastreams.each do |datastream|
+        ds = json['datastreams'].detect{|s| s["id"] == datastream.id}
+        datastream.current_value.should == ds["values"].first["value"]
+        datastream.min_value.should == ds["values"].first["min_value"]
+        datastream.max_value.should == ds["values"].first["max_value"]
+        datastream.updated.should == ds["values"].first["recorded_at"]
+        datastream.tags.should == ds["tags"].join(',')
+        if ds["unit"]
+          no_units = false
+          datastream.unit_label.should == ds["unit"]["label"]
+          datastream.unit_symbol.should == ds["unit"]["symbol"]
+          datastream.unit_type.should == ds["unit"]["type"]
+        end
+      end
+      raise "This test is testing a feed with no datastream units" if no_units
+      feed.id.should == json["id"]
+      json["location"].should_not be_empty
+      feed.location_disposition.should == json["location"]["disposition"]
+      feed.location_domain.should == json["location"]["domain"]
+      feed.location_ele.should == json["location"]["ele"]
+      feed.location_exposure.should == json["location"]["exposure"]
+      feed.location_lat.should == json["location"]["lat"]
+      feed.location_lon.should == json["location"]["lon"]
+      feed.location_name.should == json["location"]["name"]
+    else
+      false
+    end
+  end
+
+end
+
+

data/spec/support/fully_represent_key_matcher.rb

@@ -0,0 +1,74 @@
+RSpec::Matchers.define :fully_represent_key do |format, formatted_key|
+  match do |key|
+    case format.to_sym
+    when :xml
+      match_xml_key(key, formatted_key)
+    when :json
+      match_json_key(key, formatted_key)
+    end
+  end
+
+  failure_message_for_should do |key|
+    "expected #{key.attributes.inspect} to fully represent #{formatted_key}"
+  end
+
+  description do
+    "expected #{formatted_key.class} to be fully represented"
+  end
+
+  def match_xml_key(key, formatted_key)
+    xml = Nokogiri.parse(formatted_key)
+    key.id.should == xml.at_xpath("//id").content
+    key.expires_at.should == xml.at_xpath("//expires-at").content
+    key.key.should == xml.at_xpath("//api-key").content
+    key.user.should == xml.at_xpath("//user").content
+    key.label.should == xml.at_xpath("//label").content
+    key.private_access.should == xml.at_xpath("//private-access").content
+
+    # TODO: fix this
+    key.permissions.each_index do |permission_index|
+      permission = key.permissions[permission_index]
+      permission_node = xml.xpath("//permissions/permission")[permission_index]
+
+      permission.label.should == permission_node.at_xpath("label").content
+      permission.referer.should == permission_node.at_xpath("referer").content
+      permission.source_ip.should == permission_node.at_xpath("source-ip").content
+      permission.access_methods.should == permission_node.xpath("access-methods/access-method").collect { |a| a.content.downcase }
+
+      permission.resources.each_index do |res_index|
+        resource = permission.resources[res_index]
+        resource_node = permission_node.xpath("resources/resource")[res_index]
+
+        resource.feed_id.should == resource_node.at_xpath("feed-id").content
+        resource.datastream_id.should == resource_node.at_xpath("datastream-id").content
+        resource.datastream_trigger_id.should == resource_node.at_xpath("datastream-trigger-id").content
+      end
+    end
+  end
+
+  def match_json_key(key, formatted_key)
+    json = JSON.parse(formatted_key)["key"]
+    key.id.should == json["id"]
+    key.expires_at.should == json["expires_at"]
+    key.key.should == json["api_key"]
+    key.user.should == json["user"]
+    key.label.should == json["label"]
+    key.private_access.should == json["private_access"]
+    key.permissions.each_index do |index|
+      permission = key.permissions[index]
+
+      permission.referer.should == json["permissions"][index]["referer"]
+      permission.source_ip.should == json["permissions"][index]["source_ip"]
+      permission.label.should == json["permissions"][index]["label"]
+      permission.access_methods.should == json["permissions"][index]["access_methods"]
+
+      permission.resources.each_index do |res_index|
+        resource = permission.resources[res_index]
+
+        resource.feed_id.should == json["permissions"][index]["resources"][res_index]["feed_id"]
+        resource.datastream_id.should == json["permissions"][index]["resources"][res_index]["datastream_id"]
+        resource.datastream_trigger_id.should == json["permissions"][index]["resources"][res_index]["datastream_trigger_id"]
+      end
+    end
+  end
+end

data/spec/support/fully_represent_search_result_matcher.rb

@@ -0,0 +1,67 @@
+RSpec::Matchers.define :fully_represent_search_result do |format, formatted_search_result|
+  match do |search_result|
+    match_json_search_result(search_result, formatted_search_result)
+  end
+
+  failure_message_for_should do |search_result|
+    "expected #{search_result} to fully represent #{formatted_search_result}"
+  end
+
+  description do
+    "expected #{formatted_search_result.class} to be fully represented"
+  end
+
+  def match_json_search_result(search_result, formatted_search_result)
+    json = JSON.parse(formatted_search_result)
+    search_result.totalResults.should == json['totalResults']
+    search_result.startIndex.should == json['startIndex']
+    search_result.itemsPerPage.should == json['itemsPerPage']
+    json = json['results'].first
+    feed = search_result.results.first
+    case json['version']
+    when '1.0.0'
+      feed.title.should == json["title"]
+      feed.status.should == json["status"]
+      feed.creator.should == json["creator"]
+      feed.updated.should == json["updated"]
+      feed.website.should == json["website"]
+      feed.private.should == json["private"]
+      feed.feed.should == json["feed"]
+      no_units = true
+      feed.datastreams.should_not be_empty
+      feed.datastreams.each do |datastream|
+        ds = json['datastreams'].detect{|s| s["id"] == datastream.id}
+        datastream.current_value.should == ds["current_value"]
+        datastream.min_value.should == ds["min_value"]
+        datastream.max_value.should == ds["max_value"]
+        datastream.updated.should == ds["at"]
+        datastream.tags.should == ds["tags"].join(',')
+        if ds["unit"]
+          no_units = false
+          datastream.unit_label.should == ds["unit"]["label"]
+          datastream.unit_symbol.should == ds["unit"]["symbol"]
+          datastream.unit_type.should == ds["unit"]["type"]
+        end
+        datastream.datapoints.each do |datapoint|
+          dp = ds['datapoints'].detect{|s| s["at"] == datapoint.at}
+          datapoint.value.should == dp["value"]
+        end
+      end
+      raise "This test is testing a feed with no datastream units" if no_units
+      feed.id.should == json["id"]
+      json["location"].should_not be_empty
+      feed.location_disposition.should == json["location"]["disposition"]
+      feed.location_domain.should == json["location"]["domain"]
+      feed.location_ele.should == json["location"]["ele"]
+      feed.location_exposure.should == json["location"]["exposure"]
+      feed.location_lat.should == json["location"]["lat"]
+      feed.location_lon.should == json["location"]["lon"]
+      feed.location_name.should == json["location"]["name"]
+    else
+      false
+    end
+  end
+
+end
+
+

data/spec/support/fully_represent_trigger_matcher.rb

@@ -0,0 +1,29 @@
+RSpec::Matchers.define :fully_represent_trigger do |format, formatted_trigger|
+  match do |trigger|
+    if format.to_sym == :xml
+      match_xml_trigger(trigger, formatted_trigger)
+    end
+  end
+
+  failure_message_for_should do |trigger|
+    "expected #{trigger} to fully represent #{formatted_trigger}"
+  end
+
+  description do
+    "expected #{formatted_datapoint.class} to be fully represented"
+  end
+
+  def match_xml_trigger(trigger, formatted_trigger)
+    xml = Nokogiri.parse(formatted_trigger)
+    trigger.id.should == xml.at_xpath("//id").content
+    trigger.url.should == xml.at_xpath("//url").content
+    trigger.trigger_type.should == xml.at_xpath("//trigger-type").content
+    trigger.threshold_value.should == xml.at_xpath("//threshold-value").content
+    trigger.notified_at.should == xml.at_xpath("//notified-at").content
+    trigger.user.should == xml.at_xpath("//user").content
+    trigger.environment_id.should == xml.at_xpath("//environment-id").content
+    trigger.stream_id.should == xml.at_xpath("//stream-id").content
+  end
+end
+
+

data/spec/support/key_helper.rb

@@ -0,0 +1,74 @@
+def key_as_(format, options = {})
+  # Default data
+  # This data is based on http://api.cosm.com/v2/feeds/504
+  case format.to_s
+  when 'hash', 'json'
+    data = { "id" => 40, "key" => "abcdefghasdfaoisdj109usasdf0a9sf", "label" => "Our awesome label",
+      "user" => "lebreeze", "expires_at" => 12345, "private_access" => true,
+      "permissions" => [
+        { "source_ip" => "127.0.0.1", "referer" => "http://cosm.com",
+          "access_methods" => %w(get put post delete),
+          "resources" => [
+            { "feed_id" => 424, "datastream_id" => "1" }
+          ]
+        }
+      ]}
+  when 'xml'
+    data = <<XML
+<?xml version="1.0" encoding="UTF-8"?>
+<key>
+  <id>40</id>
+  <api-key>abcdefghasdfaoisdj109usasdf0a9sf</api-key>
+  <expires-at>12345</expires-at>
+  <user>lebreeze</user>
+  <label>Our awesome label</label>
+  <private-access>true</private-access>
+  <permissions>
+    <permission>
+      <referer>http://cosm.com</referer>
+      <source-ip>127.0.0.1</source-ip>
+      <access-methods>
+        <access-method>GET</access-method>
+        <access-method>PUT</access-method>
+        <access-method>POST</access-method>
+        <access-method>DELETE</access-method>
+      </access-methods>
+      <resources>
+        <resource>
+          <feed-id>424</feed-id>
+          <datastream-id>1</datastream-id>
+        </resource>
+      </resources>
+    </permission>
+  </permissions>
+</key>
+XML
+  end
+
+  # Add extra options we passed
+  if options[:with]
+    options[:with].each do |field, value|
+      data[field.to_s] = value
+    end
+  end
+
+  # Remove options we don't need
+  if options[:except]
+    options[:except].each do |field,_|
+      data.delete(field.to_s)
+    end
+  end
+
+  # Return the feed in the requested format
+  case format.to_s
+  when 'hash'
+    data
+  when 'json'
+    { "key" => data }.to_json
+  when 'xml'
+    data
+  else
+    raise "#{format} undefined"
+  end
+end
+