coap 0.0.16 → 0.1.0

data/test/test_message.rb

@@ -1,126 +1,154 @@
-# -*- encoding: utf-8 -*-
-require_relative 'coap_test_helper'
+# encoding: utf-8
 
-class TestMessage < Test::Unit::TestCase
+require 'helper'
+
+class TestMessage < Minitest::Test
   def test_number_of_bits_up_to
-    assert_equal 0, CoAP.number_of_bits_up_to(1)
-    assert_equal 4, CoAP.number_of_bits_up_to(16)
-    assert_equal 5, CoAP.number_of_bits_up_to(32)
-    assert_equal 7, CoAP.number_of_bits_up_to(128)
+    assert_equal 0, CoRE::CoAP.number_of_bits_up_to(1)
+    assert_equal 4, CoRE::CoAP.number_of_bits_up_to(16)
+    assert_equal 5, CoRE::CoAP.number_of_bits_up_to(32)
+    assert_equal 7, CoRE::CoAP.number_of_bits_up_to(128)
+  end
+
+  def test_path_encode
+    assert_equal "/", CoRE::CoAP.path_encode([])
+    assert_equal "/foo", CoRE::CoAP.path_encode(["foo"])
+    assert_equal "/foo/bar", CoRE::CoAP.path_encode(["foo", "bar"])
+    assert_equal "/f.o/b-r", CoRE::CoAP.path_encode(["f.o", "b-r"])
+    assert_equal "/f(o/b)r", CoRE::CoAP.path_encode(["f(o", "b)r"])
+    assert_equal "/foo/b%2Fr", CoRE::CoAP.path_encode(["foo", "b/r"])
+    assert_equal "/foo/b&r", CoRE::CoAP.path_encode(["foo", "b&r"])
+    assert_equal "/f%C3%B8o/b%C3%A4r", CoRE::CoAP.path_encode(["føo", "bär"])
   end
 
   def test_query_encode
-    assert_equal '', CoAP.query_encode([])
-    assert_equal '?', CoAP.query_encode([''])
-    assert_equal '?foo', CoAP.query_encode(['foo'])
-    assert_equal '?foo&bar', CoAP.query_encode(%w(foo bar))
-    assert_equal '?f.o&b-r', CoAP.query_encode(['f.o', 'b-r'])
-    assert_equal '?f(o&b)r', CoAP.query_encode(['f(o', 'b)r'])
-    assert_equal '?foo&b/r', CoAP.query_encode(['foo', 'b/r'])
-    assert_equal '?foo&b%26r', CoAP.query_encode(['foo', 'b&r'])
-    assert_equal '?f%C3%B8o&b%C3%A4r', CoAP.query_encode(['føo', 'bär'])
+    assert_equal "", CoRE::CoAP.query_encode([])
+    assert_equal "?", CoRE::CoAP.query_encode([""])
+    assert_equal "?foo", CoRE::CoAP.query_encode(["foo"])
+    assert_equal "?foo&bar", CoRE::CoAP.query_encode(["foo", "bar"])
+    assert_equal "?f.o&b-r", CoRE::CoAP.query_encode(["f.o", "b-r"])
+    assert_equal "?f(o&b)r", CoRE::CoAP.query_encode(["f(o", "b)r"])
+    assert_equal "?foo&b/r", CoRE::CoAP.query_encode(["foo", "b/r"])
+    assert_equal "?foo&b%26r", CoRE::CoAP.query_encode(["foo", "b&r"])
+    assert_equal "?f%C3%B8o&b%C3%A4r", CoRE::CoAP.query_encode(["føo", "bär"])
   end
 
   # XXX: now properly checks for trailing slashes, how much trouble?
   def test_path_decode
-    assert_equal [], CoAP.path_decode('/')
-    assert_equal ['foo'], CoAP.path_decode('/foo')
-    assert_equal ['foo', ''], CoAP.path_decode('/foo/') # confusing!
-    assert_equal %w(foo bar), CoAP.path_decode('/foo/bar')
-    assert_equal ['f.o', 'b-r'], CoAP.path_decode('/f.o/b-r')
-    assert_equal ['f(o', 'b)r'], CoAP.path_decode('/f(o/b)r')
-    assert_equal ['foo', 'b/r'], CoAP.path_decode('/foo/b%2Fr')
-    assert_equal ['foo', 'b&r'], CoAP.path_decode('/foo/b&r')
-    assert_equal ['føo', 'bär'], CoAP.path_decode('/f%C3%B8o/b%C3%A4r')
+    assert_equal [], CoRE::CoAP.path_decode("/")
+    assert_equal ["foo"], CoRE::CoAP.path_decode("/foo")
+    assert_equal ["foo", ""], CoRE::CoAP.path_decode("/foo/") # confusing!
+    assert_equal ["foo", "bar"], CoRE::CoAP.path_decode("/foo/bar")
+    assert_equal ["f.o", "b-r"], CoRE::CoAP.path_decode("/f.o/b-r")
+    assert_equal ["f(o", "b)r"], CoRE::CoAP.path_decode("/f(o/b)r")
+    assert_equal ["foo", "b/r"], CoRE::CoAP.path_decode("/foo/b%2Fr")
+    assert_equal ["foo", "b&r"], CoRE::CoAP.path_decode("/foo/b&r")
+    assert_equal ["føo", "bär"], CoRE::CoAP.path_decode("/f%C3%B8o/b%C3%A4r")
   end
 
   # XXX: now checks for trailing ampersands
   def test_query_decode
-    assert_equal [], CoAP.query_decode('')
-    assert_equal [''], CoAP.query_decode('?')
-    assert_equal ['foo'], CoAP.query_decode('?foo')
-    assert_equal ['foo', ''], CoAP.query_decode('?foo&')
-    assert_equal %w(foo bar), CoAP.query_decode('?foo&bar')
-    assert_equal ['f.o', 'b-r'], CoAP.query_decode('?f.o&b-r')
-    assert_equal ['f(o', 'b)r'], CoAP.query_decode('?f(o&b)r')
-    assert_equal ['foo', 'b/r'], CoAP.query_decode('?foo&b/r')
-    assert_equal ['foo', 'b&r'], CoAP.query_decode('?foo&b%26r')
-    assert_equal ['føo', 'bär'], CoAP.query_decode('?f%C3%B8o&b%C3%A4r')
+    assert_equal [], CoRE::CoAP.query_decode("")
+    assert_equal [], CoRE::CoAP.query_decode("?")
+    assert_equal ["foo"], CoRE::CoAP.query_decode("?foo")
+    assert_equal ["foo", ""], CoRE::CoAP.query_decode("?foo&")
+    assert_equal ["foo", "bar"], CoRE::CoAP.query_decode("?foo&bar")
+    assert_equal ["f.o", "b-r"], CoRE::CoAP.query_decode("?f.o&b-r")
+    assert_equal ["f(o", "b)r"], CoRE::CoAP.query_decode("?f(o&b)r")
+    assert_equal ["foo", "b/r"], CoRE::CoAP.query_decode("?foo&b/r")
+    assert_equal ["foo", "b&r"], CoRE::CoAP.query_decode("?foo&b%26r")
+    assert_equal ["føo", "bär"], CoRE::CoAP.query_decode("?f%C3%B8o&b%C3%A4r")
   end
 
   def test_scheme_and_authority_encode
-    assert_equal 'coap://foo.bar:4711', CoAP.scheme_and_authority_encode('foo.bar', 4711)
-    assert_equal 'coap://foo.bar:4711', CoAP.scheme_and_authority_encode('foo.bar', '4711')
-    assert_raise ArgumentError do
-      CoAP.scheme_and_authority_encode('foo.bar', 'baz')
+    assert_equal "coap://foo.bar:4711", CoRE::CoAP.scheme_and_authority_encode("foo.bar", 4711)
+    assert_equal "coap://foo.bar:4711", CoRE::CoAP.scheme_and_authority_encode("foo.bar", "4711")
+    assert_raises ArgumentError do
+      CoRE::CoAP.scheme_and_authority_encode("foo.bar", "baz")
     end
-    assert_equal 'coap://bar.baz', CoAP.scheme_and_authority_encode('bar.baz', 5683)
-    assert_equal 'coap://bar.baz', CoAP.scheme_and_authority_encode('bar.baz', '5683')
+    assert_equal "coap://bar.baz", CoRE::CoAP.scheme_and_authority_encode("bar.baz", 5683)
+    assert_equal "coap://bar.baz", CoRE::CoAP.scheme_and_authority_encode("bar.baz", "5683")
   end
 
   def test_scheme_and_authority_decode
-    assert_equal ['foo.bar', 4711, nil], CoAP.scheme_and_authority_decode('coap://foo.bar:4711')
-    assert_equal ['foo.bar', 5683, nil], CoAP.scheme_and_authority_decode('coap://foo.bar')
-    assert_equal ['foo:bar', 4711, nil], CoAP.scheme_and_authority_decode('coap://[foo:bar]:4711')
-    assert_equal ['foo:bar', 5683, nil], CoAP.scheme_and_authority_decode('coap://%5Bfoo:bar%5D')
+    assert_equal [nil, "foo.bar", 4711], CoRE::CoAP.scheme_and_authority_decode("coap://foo.bar:4711")
+    assert_equal [nil, "foo.bar", 5683], CoRE::CoAP.scheme_and_authority_decode("coap://foo.bar")
+    assert_equal [nil, "foo:bar", 4711], CoRE::CoAP.scheme_and_authority_decode("coap://[foo:bar]:4711")
+    assert_equal [nil, "foo:bar", 5683], CoRE::CoAP.scheme_and_authority_decode("coap://%5Bfoo:bar%5D")
   end
 
   def test_coap_message
-    input = "\x44\x02\x12\xA0abcd\x41A\x7B.well-known\x04core\x0D\x04rhabarbersaftglas\xFFfoobar".force_encoding('BINARY')
-    output = CoAP.parse(input)
+    input = "\x44\x02\x12\xA0abcd\x41A\x7B.well-known\x04core\x0D\x04rhabarbersaftglas\xFFfoobar".force_encoding("BINARY")
+    Log.debug input.hexdump('input ')
+    output = CoRE::CoAP.parse(input)
+    Log.debug output
+    Log.debug "critical?: #{output.options.map { |k, v| [k, CoRE::CoAP.critical?(k)]}.inspect}"
     w = output.to_wire
+    Log.debug w.hexdump('output ')
     assert_equal input, w
   end
 
-# XXX TODO add token tests
+  # XXX TODO add token tests
 
   def test_fenceposting
-    m = CoAP::Message.new(:con, :get, 4711, 'Hello', {})
-    m.options = { max_age: 987_654_321, if_none_match: true }
+    m = CoRE::CoAP::Message.new(:con, :get, 4711, "Hello")
+    Log.debug m
+    m.options = { max_age: 987654321, if_none_match: true }
+    Log.debug m
     me = m.to_wire
-    m2 = CoAP.parse(me)
-    m.options = CoAP::DEFAULTING_OPTIONS.merge(m.options)
+    Log.debug me.inspect
+    m2 = CoRE::CoAP::parse(me)
+    Log.debug m2
+    m.options = CoRE::CoAP::DEFAULTING_OPTIONS.merge(m.options)
     assert_equal m2, m
   end
 
   def test_fenceposting2
-    m = CoAP::Message.new(:con, :get, 4711, 'Hello', {})
-    m.options = { 4711 => ['foo'], 256 => ['bar'] }
+    m = CoRE::CoAP::Message.new(:con, :get, 4711, "Hello")
+    Log.debug m
+    m.options = { 4711 => ["foo"], 256 => ["bar"] }
+    Log.debug m
     me = m.to_wire
-    m2 = CoAP.parse(me)
-    m.options = CoAP::DEFAULTING_OPTIONS.merge(m.options)
+    Log.debug me.inspect
+    m2 = CoRE::CoAP::parse(me)
+    Log.debug m2
+    m.options = CoRE::CoAP::DEFAULTING_OPTIONS.merge(m.options)
     assert_equal m2, m
   end
 
   def test_emptypayload
-    m = CoAP::Message.new(:con, :get, 4711, '', {})
-    m.options = { 4711 => ['foo'], 256 => ['bar'], 65_535 => ['abc' * 100] }
+    m = CoRE::CoAP::Message.new(:con, :get, 4711, "")
+    Log.debug m
+    m.options = { 4711 => ["foo"], 256 => ["bar"], 65535 => ["abc" * 100] }
+    Log.debug m
     me = m.to_wire
-    m2 = CoAP.parse(me)
-    m.options = CoAP::DEFAULTING_OPTIONS.merge(m.options)
+    Log.debug me.inspect
+    m2 = CoRE::CoAP::parse(me)
+    Log.debug m2
+    m.options = CoRE::CoAP::DEFAULTING_OPTIONS.merge(m.options)
     assert_equal m2, m
   end
 
   def test_option_numbers
-    (0...65_536).each do |on|
-      unless CoAP::OPTIONS[on] # those might have special semantics
-        m = CoAP::Message.new(:con, :get, 4711, 'Hello', {})
-        m.options = { on => [''] }
+    (0...65536).each do |on|
+      unless CoRE::CoAP::OPTIONS[on] # those might have special semantics
+        m = CoRE::CoAP::Message.new(:con, :get, 4711, "Hello")
+        m.options = { on => [""] }
         me = m.to_wire
-        m2 = CoAP.parse(me)
-        m.options = CoAP::DEFAULTING_OPTIONS.merge(m.options)
+        m2 = CoRE::CoAP::parse(me)
+        m.options = CoRE::CoAP::DEFAULTING_OPTIONS.merge(m.options)
         assert_equal m2, m
       end
     end
   end
 
   def test_option_lengths
-    (0...1024).each do |ol|
-      m = CoAP::Message.new(:con, :get, 4711, 'Hello', {})
-      m.options = { 99 => ['x' * ol] }
+    (0...1035).each do |ol|
+      m = CoRE::CoAP::Message.new(:con, :get, 4711, "Hello")
+      m.options = { 99 => ["x"*ol] }
       me = m.to_wire
-      m2 = CoAP.parse(me)
-      m.options = CoAP::DEFAULTING_OPTIONS.merge(m.options)
+      m2 = CoRE::CoAP::parse(me)
+      m.options = CoRE::CoAP::DEFAULTING_OPTIONS.merge(m.options)
       assert_equal m2, m
     end
   end

metadata

@@ -1,15 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: coap
 version: !ruby/object:Gem::Version
-  version: 0.0.16
+  version: 0.1.0
 platform: ruby
 authors:
 - Carsten Bormann
 - Simon Frerichs
+- henning mueller
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-10 00:00:00.000000000 Z
+date: 2015-01-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -17,56 +18,131 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.5'
+        version: '1.6'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.5'
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+- !ruby/object:Gem::Dependency
+  name: faker
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.4'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '10.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.3'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: celluloid-io
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.16'
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.16.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.16'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.16.1
 - !ruby/object:Gem::Dependency
   name: resolv-ipv6favor
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0'
 description: |-
-  Ruby Gem for RFC 7252 - Constrained Application Protocol (CoAP)
-  The Constrained Application Protocol (CoAP) is a specialized web
-  transfer protocol for use with constrained nodes and constrained
-  (e.g., low-power, lossy) networks.  The nodes often have 8-bit
-  microcontrollers with small amounts of ROM and RAM, while constrained
-  networks such as 6LoWPAN often have high packet error rates and a
-  typical throughput of 10s of kbit/s.  The protocol is designed for
-  machine-to-machine (M2M) applications such as smart energy and
-  building automation
-email:
-- morpheus@morphhome.net
+  Pure Ruby implementation of RFC 7252 (Constrained Application
+      Protocol (CoAP)). The Constrained Application Protocol (CoAP) is a
+      specialized web transfer protocol for use with constrained nodes and
+      constrained (e.g., low-power, lossy) networks. The nodes often have 8-bit
+      microcontrollers with small amounts of ROM and RAM, while constrained
+      networks such as IPv6 over Low-Power Wireless Personal Area Networks
+      (6LoWPANs) often have high packet error rates and a typical throughput of
+      10s of kbit/s. The protocol is designed for machine-to-machine (M2M)
+      applications such as smart energy and building automation.
+email: henning@orgizm.net
 executables:
-- client
+- coap
 extensions: []
 extra_rdoc_files: []
 files:
@@ -76,22 +152,42 @@ files:
 - LICENSE
 - README.md
 - Rakefile
-- bin/client
+- bin/coap
 - coap.gemspec
 - lib/coap.rb
-- lib/coap/block.rb
-- lib/coap/client.rb
-- lib/coap/coap.rb
-- lib/coap/message.rb
-- lib/coap/mysocket.rb
-- lib/coap/observer.rb
-- lib/coap/version.rb
-- lib/misc/hexdump.rb
-- test/coap_test_helper.rb
-- test/disabled_econotag_blck.rb
+- lib/core.rb
+- lib/core/coap.rb
+- lib/core/coap/block.rb
+- lib/core/coap/client.rb
+- lib/core/coap/coap.rb
+- lib/core/coap/coding.rb
+- lib/core/coap/fsm.rb
+- lib/core/coap/message.rb
+- lib/core/coap/observer.rb
+- lib/core/coap/options.rb
+- lib/core/coap/registry.rb
+- lib/core/coap/registry/content_formats.yml
+- lib/core/coap/resolver.rb
+- lib/core/coap/transmission.rb
+- lib/core/coap/types.rb
+- lib/core/coap/utility.rb
+- lib/core/coap/version.rb
+- lib/core/core_ext/socket.rb
+- lib/core/hexdump.rb
+- lib/core/link.rb
+- lib/core/os.rb
+- spec/block_spec.rb
+- spec/client_spec.rb
+- spec/fixtures/coap.me.link
+- spec/link_spec.rb
+- spec/registry_spec.rb
+- spec/resolver_spec.rb
+- spec/spec_helper.rb
+- spec/transmission_spec.rb
+- test/helper.rb
 - test/test_client.rb
 - test/test_message.rb
-homepage: https://github.com/SmallLars/coap
+homepage: https://github.com/nning/coap
 licenses:
 - MIT
 metadata: {}
@@ -111,12 +207,19 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
-summary: Ruby Gem for RFC 7252 - Constrained Application Protocol (CoAP)
+summary: Pure Ruby implementation of RFC 7252 (Constrained Application Protocol (CoAP))
 test_files:
-- test/coap_test_helper.rb
-- test/disabled_econotag_blck.rb
+- spec/block_spec.rb
+- spec/client_spec.rb
+- spec/fixtures/coap.me.link
+- spec/link_spec.rb
+- spec/registry_spec.rb
+- spec/resolver_spec.rb
+- spec/spec_helper.rb
+- spec/transmission_spec.rb
+- test/helper.rb
 - test/test_client.rb
 - test/test_message.rb