assert-url 0.0.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,15 @@
 ---
-SHA1:
-  metadata.gz: cbc3fcdf6ef6d4249a7acc90d7a50400daa6e653
-  data.tar.gz: 5c6d6af45be495d1608664f39e3d31a59343053a
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    NDY2MTI0ZTRmY2NiYWE1MjA0M2RkYWU4Y2MxZDc3YTQ2ZTgyMDhiYQ==
+  data.tar.gz: !binary |-
+    YTRkNDAzMTU3ZjAxMjkyNTQ2YzQ4NWU1ZGE3NDdhMGM3NTIwNzE0Mw==
 SHA512:
-  metadata.gz: 93a675818fed1f17a8905e770e879e8cf1ff2f481f17a64770b1e6f0338df85a46a8da1e37695b7f02b296a5ea125905d58964b61d4842131c6887066e80fabb
-  data.tar.gz: ab51556324b3ef568297afb10ec4263ed01320d1f3dad068b9202780413cfd19f322a7161496eec5e72900a3a4f966099f3a73a400954c0b84b6e356c3abc00c
+  metadata.gz: !binary |-
+    ZDY3OGY4ZTFmOTU4MzBmYmRlOTQxZWRjYzUyMDYwMjQyNjJjOTc0ZmFmNjUy
+    Y2ZmYzE1MTcxYjQzNmMxOWZmMmMzOGQ4NjUwZDAxOGQ0YTUwYzA5Y2RlZDMx
+    NDUyMTgxM2QxYTQ4M2U3NGM2M2FjYjYzYzhhOWY1ZGM5MWEyODA=
+  data.tar.gz: !binary |-
+    ODZjYThmNzAwM2RlYmNiNzdhZjM2NmIwNTNkZTM3NjZhOTU5Nzg4MDVjODNk
+    NDZhMjcyNTkxYjQzZDMzNDk0NDgxMGE2ZDZlYmNkMmYyZThjOTIzZWNlZTZl
+    ZDcyZjc5MDg0NThiZTg0NjIzNmFjYjA4NThhNzUzZGI1NTA4YTI=

data/README.md

@@ -2,3 +2,65 @@ assert-url
 ==========
 
 Semantical helpers to test your URLs in Ruby
+
+## Usage
+
+Ok, say you're writing a Web app with Ruby (who isn't?) and need to test your routing with `Rack::Test`.
+
+### The old way
+
+```ruby
+def test_some_resource
+  get "/some/resource"
+
+  assert last_response.ok?
+  assert_equal "http://example.org/some/resource", last_response.url
+end
+```
+
+What's wrong with this, you ask? Well, in most cases when you write a test like this, you only care about testing the `/some/resource` path, but the rest (scheme, port, etc) doesn't really matter. Still we're used to use `assert_equal` on the whole url.
+
+Now imagine that you need to change the port, scheme or host. Now imagine you have hundreds of tests. It's `grep` day, my friend.
+
+### Enter AssertUrl!
+
+```ruby
+include AssertUrl
+
+def test_some_resource
+  get "/some/resource"
+
+  assert last_response.ok?
+  assert_path_equal "/some/resource", last_response.url
+end
+```
+
+BAM! Now you're only testing what you need. You can change the port, host, even the query and the test will be fine.
+
+`AssertUrl` provides the following assertions in the form of `expected, value`:
+* `assert_scheme_equal [String or Symbol], [String or URI]`
+* `assert_host_equal [String], [String or URI]`
+* `assert_port_equal [Integer], [String or URI]`
+* `assert_path_equal [String starting with "/"], [String or URI]`
+* `assert_query_equal [Hash], [String or URI]`
+* `assert_query_include [Hash], [String or URI]`
+* `assert_fragment_equal [String], [String or URI]`
+* `assert_url_equal [String or URI], [String or URI]`
+
+### But...
+
+Can't I just do something like...?
+
+```ruby
+assert_equal "/some/resource", URI(last_response.url).path
+```
+
+Well, yes! sure you can. In fact, this is very close to how `AssertUrl` is implemented.
+
+My point here is not to sell you this gem but to make a statement that we need a better habit when testing URLs. And if `AssertUrl` helps you with it, great!
+
+## Installation
+
+```
+gem install assert-url
+```

data/assert_url.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = "assert-url"
-  s.version = "0.0.1"
+  s.version = "1.0.0"
   s.summary = "Semantical helpers to test your URLs in Ruby"
   s.description = s.summary
   s.authors = ["Lucas Tolchinsky"]

data/lib/assert_url.rb

@@ -1,29 +1,54 @@
 require "uri"
 
 module AssertUrl
-  PARTS = %W[scheme host port path query]
+  PARTS = %W[scheme host port path query fragment]
 
   PARTS.each do |part|
     error = const_set("#{part.capitalize}Error", Class.new(StandardError))
 
-    define_method(:"assert_#{part}") do |expected, value|
-      expected, value = urify(expected, value).map(&:"#{part}")
+    define_method(:"assert_#{part}_equal") do |expected, value|
+      expected = normalize(part, expected)
+      value = urify(value).send(part.to_sym)
 
       expected == value || (raise error, "expected #{expected}, got #{value}")
     end
   end
 
-  alias assert_hostname assert_host
+  def assert_url_equal(expected, value)
+    expected, value = urify(expected), urify(value)
 
-  def assert_url(expected, value)
-    expected, value = urify(expected, value)
+    PARTS.map { |part| send(:"assert_#{part}_equal", expected.send(part.to_sym), value) }.reduce(:&)
+  end
+
+  def assert_query_include(expected, value)
+    value = Hash[URI.decode_www_form(urify(value).query)]
+
+    includes?(expected.to_a, value) || (raise QueryError, "expected #{value} to include #{expected}")
+  end
 
-    PARTS.map { |part| send(:"assert_#{part}", expected, value) }.reduce(:&)
+  def includes?(expected, got)
+    expected.all? do |(key, value)|
+      key = key.to_s
+      got.has_key?(key) && got[key] == value
+    end
   end
+  private :includes?
 
-  def urify(*args)
-    args.each_with_object([]) { |arg, accum| accum << (arg.kind_of?(URI) ? arg : URI(arg)) }
+  def urify(arg)
+    arg.kind_of?(URI) ? arg : URI(arg)
   end
   private :urify
+
+  def normalize(part, expected)
+    case part
+    when "scheme"
+      expected.kind_of?(Symbol) ? expected.to_s : expected
+    when "query"
+      URI.encode_www_form(expected) rescue expected
+    else
+      expected
+    end
+  end
+  private :normalize
 end
 

data/test/assert_url_test.rb

@@ -5,54 +5,70 @@ require_relative "../lib/assert_url"
 include AssertUrl
 
 setup do
-  "http://sub.example.org:8080/path/to/resource?foo=bar"
+  "http://sub.example.org:8080/path/to/resource?foo=bar#fragment"
 end
 
-test "assert_url" do |url|
-  assert assert_url(url, url)
-
-  assert_raise do
-    assert_scheme("https://example.org", url)
-  end
-end
-
-test "assert_scheme" do |url|
-  assert assert_scheme("http://example.org", url)
+test "assert_scheme_equal" do |url|
+  assert assert_scheme_equal("http", url)
+  assert assert_scheme_equal(:http, url)
 
   assert_raise(AssertUrl::SchemeError) do
-    assert_scheme("ftp://example.org", url)
+    assert_scheme_equal("ftp", url)
   end
 end
 
-test "assert_host" do |url|
-  assert assert_host("https://sub.example.org", url)
+test "assert_host_equal" do |url|
+  assert assert_host_equal("sub.example.org", url)
 
   assert_raise(AssertUrl::HostError) do
-    assert_host("http://example.org", url)
+    assert_host_equal("example.org", url)
   end
 end
 
-test "assert_port" do |url|
-  assert assert_port("http://place.org:8080", url)
+test "assert_port_equal" do |url|
+  assert assert_port_equal(8080, url)
 
   assert_raise(AssertUrl::PortError) do
-    assert_port("ftp://example.org", url)
+    assert_port_equal(80, url)
   end
 end
 
-test "assert_path" do |url|
-  assert assert_path("http://wat.org/path/to/resource", url)
+test "assert_path_equal" do |url|
+  assert assert_path_equal("/path/to/resource", url)
 
   assert_raise(AssertUrl::PathError) do
-    assert_path("ftp://example.org", url)
+    assert_path_equal("/not/the/resource", url)
+  end
+end
+
+test "assert_query_equal" do |url|
+  assert assert_query_equal({foo: "bar"}, url)
+
+  assert_raise(AssertUrl::QueryError) do
+    assert_query_equal("", url)
   end
 end
 
-test "assert_query" do |url|
-  assert assert_query("http://foo.bar/q?foo=bar", url)
+test "assert_query_include" do
+  assert assert_query_include({foo: "bar"}, "http://example.org/?foo=bar&baz=wat")
 
   assert_raise(AssertUrl::QueryError) do
-    assert_query("ftp://example.org", url)
+    assert_query_include({foo: "wat"}, "http://example.org/?foo=bar&baz=wat")
+  end
+end
+
+test "assert_fragment_equal" do |url|
+  assert assert_fragment_equal("fragment", url)
+
+  assert_raise(AssertUrl::FragmentError) do
+    assert_fragment_equal("not", url)
   end
 end
 
+test "assert_url_equal" do |url|
+  assert assert_url_equal(url, url)
+
+  assert_raise do
+    assert_url_equal("https://example.org", url)
+  end
+end

metadata

@@ -1,27 +1,27 @@
 --- !ruby/object:Gem::Specification
 name: assert-url
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Lucas Tolchinsky
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-21 00:00:00.000000000 Z
+date: 2014-08-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cutest
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
 description: Semantical helpers to test your URLs in Ruby
@@ -46,17 +46,17 @@ 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.2.0
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Semantical helpers to test your URLs in Ruby