url_tracker 0.1

data/bin/ut

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/url_tracker'
+
+UrlTracker::Client.new.run(ARGV)

data/bin/utd

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/url_tracker'
+
+UrlTracker::Server.new.run(ARGV)

data/lib/url_tracker.rb

@@ -0,0 +1,70 @@
+require 'notifier'
+
+module UrlTracker
+  require_relative 'url_tracker/version'
+  require_relative 'url_tracker/page'
+  require_relative 'url_tracker/periodic'
+  require_relative 'url_tracker/socket_communication'
+  require_relative 'url_tracker/client'
+  require_relative 'url_tracker/server'
+
+  extend self
+
+  require 'set'
+
+  # Tracks +url+ fetching its content every +time+ seconds (defaults
+  # to 5*60 - 5 minutes).
+  def track_uri(uri, time = 5*60)
+    init_ivars
+
+    p = Page.new(URI(uri))
+    
+    if @pages.add?(p)
+      @scheduler.task(uri).every(:minute) { check_change(p) }
+      'ok'
+    else
+      'error'
+    end
+  end
+
+  # Returns an array with all URIs currently being tracked
+  def list_all
+    init_ivars
+    uri_list = @pages.map { |page| page.uri }
+
+    uri_list.empty? ? ',' : uri_list.join(',')
+  end
+
+  # Stops tracking given URI
+  def release_uri(uri)
+    init_ivars
+
+    p = Page.new(URI(uri))
+    if @pages.include?(p)
+      @pages.delete(p)
+      @scheduler.remove_task(uri)
+      'ok'
+    else
+      'error'
+    end
+  end
+
+  # Forget about current tracked URIs
+  def restart
+    init_ivars
+    @pages.clear
+    @scheduler.restart
+  end
+
+private
+
+  def check_change(page)
+    Notifier.notify(title: 'Change!', message: "Page #{page.uri} changed!") if page.changed?
+  end
+
+  def init_ivars
+    @pages      ||= Set.new
+    @scheduler  ||= Periodic.new
+  end
+  
+end

data/test/test_client.rb

@@ -0,0 +1,88 @@
+require_relative 'test_helper'
+
+class TestClient < MiniTest::Unit::TestCase
+
+  def setup
+    remove_socket
+    @server = Object.new.extend(UrlTracker::SocketCommunication)
+    @server.bind(socket_file)
+
+    async do
+      @server.wait_for_connection
+    end
+
+    @client = UrlTracker::Client.new(socket_file)
+
+    wait_sync
+  end
+
+  def teardown
+    @client.close_connection
+    @server.close_connection
+  end
+
+  def test_successful_track_new_url
+    async { @success = @client.track(fake_url) }
+    @server.write('ok')
+    wait_sync
+
+    assert_equal "track #{fake_url}", @server.next_message
+    assert @success
+  end
+
+  def test_server_could_not_track_url
+    async { @success = @client.track(fake_url) }
+    @server.write('error')
+    wait_sync
+
+    assert !@success
+  end
+
+  def test_list_urls_empty
+    async { @urls = @client.list }
+    @server.write(',')
+    wait_sync
+
+    assert_empty @urls
+  end
+
+  def test_list_single_url
+    async { @urls = @client.list }
+    @server.write(fake_url)
+    wait_sync
+
+    assert_equal [fake_url], @urls
+  end
+
+  def test_list_multiple_urls
+    async { @urls = @client.list }
+    @server.write(fake_url + ',http://foo.bar,http://google.com')
+    wait_sync
+
+    assert_equal [fake_url, 'http://foo.bar', 'http://google.com'], @urls
+  end
+
+  def test_release_tracked_url
+    async { @client.track(fake_url) }
+    @server.write('ok')
+    wait_sync
+
+    @server.next_message # so that we don't get the tracking request on the assertion
+
+    async { @success = @client.release(fake_url) }
+    @server.write('ok')
+    wait_sync
+
+    assert_equal "release #{fake_url}", @server.next_message
+    assert @success
+  end
+
+  def test_release_url_not_tracked
+    async { @success = @client.release(fake_url) }
+    @server.write('error')
+    wait_sync
+
+    assert !@success
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,42 @@
+require 'minitest/autorun'
+require 'minitest/pride'
+require_relative '../lib/url_tracker'
+
+# messages sent via sockets in the tests cannot be longer than 100 bytes
+MAX_TEST_SOCK_MESSAGE = 100 
+
+puts "Url Tracker: running on Ruby version #{RUBY_VERSION}"
+
+def assert_socket_received(message, socket)
+  assert_block("Expected #{socket.inspect} to receive #{message.inspect}") do
+    socket.recvfrom(MAX_TEST_SOCK_MESSAGE).first == message
+  end
+end
+
+def async(stop = false, &block)
+  @t = Thread.new(&block)
+  @t.abort_on_exception = true
+
+  while !@t.stop?; end if stop
+end
+
+def wait_sync
+  @t.join
+end
+
+def finish_async
+  @t.terminate
+  @t.join
+end
+
+def remove_socket
+  File.unlink(socket_file) if File.exists?(socket_file)
+end
+
+def socket_file
+  '/tmp/.dk29ei39kd3.sock'
+end
+
+def fake_url
+  'http://fake.com'
+end

data/test/test_page.rb

@@ -0,0 +1,52 @@
+require_relative 'test_helper'
+
+class TestPage < MiniTest::Unit::TestCase
+
+  def setup
+    @page_fetcher = MiniTest::Mock.new
+    @content = 'web page'
+
+    # should receive method get with argument fake_url and return @content
+    @page_fetcher.expect(:get, @content, [fake_url])
+
+    @page = UrlTracker::Page.new(fake_url, @page_fetcher)
+  end
+
+  def test_page_content
+    assert_equal @content, @page.content
+  end
+
+  def test_page_content_bang
+    assert_equal @content, @page.content
+
+    change_page_content('new content')
+    assert_equal 'new content', @page.content!
+  end
+
+  def test_page_changed_before_cached_content
+    assert !@page.changed?, 'Expected no changes when there is no cache of the page'
+  end
+
+  def test_page_changed_when_no_changes_happened
+    @page.content # we now have a cache of the page
+
+    assert !@page.changed?, 'Expected a false result when no changes occur to a page'
+  end
+
+  def test_page_changed_when_changes_really_happened
+    @page.content
+    change_page_content('new content')
+
+    assert @page.changed?, 'Expected Page to indicate change when its content was changed'
+  end
+
+  def change_page_content(new_content)
+    @page_fetcher.expect(:get, new_content, [fake_url])
+  end
+
+  def test_page_equality
+    other_page = UrlTracker::Page.new(fake_url)
+    assert_equal @page, other_page
+  end
+
+end

data/test/test_periodic.rb

@@ -0,0 +1,78 @@
+require_relative 'test_helper'
+
+class TestPeriodic < MiniTest::Unit::TestCase
+
+  def setup
+    @p = UrlTracker::Periodic.new
+  end
+
+  def teardown
+    @p.stop
+  end
+
+  def test_every_with_symbol_argument
+    assert_equal 60, @p.every(:minute) {}
+  end
+
+  def test_every_with_hour_symbol
+    assert_equal 60*60, @p.every(:hour) {}
+  end
+
+  def test_two_minutes
+    assert_equal 2*60, @p.every(2, :minutes) {}
+  end
+
+  def test_two_hours
+    assert_equal 2*60*60, @p.every(2, :hours) {}
+  end
+
+  def test_invalid_first_argument
+    assert_raises(RuntimeError) do
+      @p.every(:invalid) {}
+    end
+  end
+
+  def test_invalid_time_unit
+    assert_raises(RuntimeError) do
+      @p.every(2, :invalid) {}
+    end
+  end
+
+  def test_add_named_task
+    @p.task("dummy").every(:minute) {}
+    assert_equal ["dummy"], @p.named_tasks
+  end
+
+  def test_remove_named_task
+    @p.task("dummy").every(:minute) {}
+    @p.remove_task("dummy")
+
+    assert_empty @p.named_tasks
+  end
+
+  def test_remove_inexistent_task
+    assert_raises(RuntimeError) do
+      @p.remove_task("dummy")
+    end
+  end
+
+  def test_restart
+    @p.stop
+    assert !@p.running?
+
+    @p.restart
+    assert @p.running?
+  end
+
+  def test_running
+    assert @p.running?, 'Expected Periodic to be running when `stop` was not called.'
+  end
+
+  def test_running_when_asked_to_stop
+    @p.stop
+
+    assert !@p.running?, 'Expected Periodic to stop'
+    @p.restart
+  end
+
+end

data/test/test_server.rb

@@ -0,0 +1,71 @@
+require_relative 'test_helper'
+
+class TestServer < MiniTest::Unit::TestCase
+
+  def setup
+    remove_socket
+    @server = UrlTracker::Server.new(Logger.new('/dev/null'))
+
+    async(true) { @server.run(socket_file: socket_file) }
+
+    @client = UrlTracker::Client.new(socket_file) # connected!
+  end
+
+  def teardown
+    @client.close_connection
+    finish_async
+    @server.close_connection
+    UrlTracker.restart
+  end
+
+  def test_successfully_tracks_url
+    assert @client.track(fake_url), 'Expected to be able to track new URI'
+  end
+
+  def test_track_same_url
+    @client.track(fake_url)
+    restart_client
+  
+    assert !@client.track(fake_url), 'Expected to return false when tracking same URI'
+  end
+
+  def test_list_empty
+    assert_equal [], @client.list
+  end
+
+  def test_list_with_single_uri
+    @client.track(fake_url)
+    restart_client
+
+    assert_equal [fake_url], @client.list
+  end
+
+  def test_list_two_uris
+    @client.track(fake_url)
+    restart_client
+    @client.track(fake_url + '/fake')
+    restart_client
+
+    assert_equal [fake_url, fake_url + '/fake'], @client.list
+  end
+
+  def test_release_when_tracking_nothing
+    assert !@client.release(fake_url), 'Expected to return false when releasing not tracked URI'
+  end
+
+  def test_release_with_tracked_uri
+    @client.track(fake_url)
+    restart_client
+    assert @client.release(fake_url), 'Expected to release tracked URI'
+    
+    restart_client
+    assert_equal [], @client.list
+  end
+
+  def restart_client
+    @client.close_connection
+
+    @client = UrlTracker::Client.new(socket_file)
+  end
+
+end

data/test/test_socket_communication.rb

@@ -0,0 +1,89 @@
+require_relative 'test_helper'
+
+class TestSocketCommunication < MiniTest::Unit::TestCase
+
+  def setup
+    @client = Object.new.extend(UrlTracker::SocketCommunication)
+    @server = Object.new.extend(UrlTracker::SocketCommunication)
+    @path    = '/tmp/.dk29ei39kd3.sock'
+    remove_socket
+  end
+
+  def teardown
+    [@client, @server].each { |o| o.close_connection }
+  end
+
+  def test_connect_to_valid_socket
+    @server.bind(@path)
+    assert @client.connect(@path), 'Should connect when given a valid socket file'
+  end
+
+  def test_raises_invalid_socket_with_bind_and_connect
+    @server.bind(@path)
+
+    assert_raises(UrlTracker::SocketCommunication::InvalidSocketError) do
+      @server.connect(@path)
+    end
+  end
+
+  def test_raises_invalid_socket_with_connect_and_bind
+    @server.bind(@path)
+    @client.connect(@path)
+
+    assert_raises(UrlTracker::SocketCommunication::InvalidSocketError) do
+      @client.bind(@path)
+    end
+  end
+
+  def test_communication_client_to_server
+    connect_server_and_client
+
+    @client.write('message')
+
+    assert_equal 'message', @server.next_message
+  end
+
+  def test_communication_server_to_client
+    connect_server_and_client
+
+    @server.write('message')
+
+    assert_equal 'message', @client.next_message
+  end
+
+  def test_communication_bidirectional
+    connect_server_and_client
+
+    @server.write('server mesg')
+    @client.write('client mesg')
+
+    assert_equal 'client mesg', @server.next_message
+    assert_equal 'server mesg', @client.next_message
+  end
+
+  def test_closing_client_connection_doesnt_remove_socket_file
+    connect_server_and_client
+    @client.close_connection
+
+    assert File.exists?(@path), 'Expected socket file to exist when closing client connection'
+  end
+
+  def test_closing_server_connection_removes_socket_file
+    connect_server_and_client
+    @server.close_connection
+
+    assert !File.exists?(@path), 'Expected socket file to be removed when server closes connection'
+  end
+
+  def remove_socket
+    File.unlink @path if File.exists? @path
+  end
+
+  def connect_server_and_client
+    @server.bind(@path)
+    t = Thread.new { @server.wait_for_connection }
+    @client.connect(@path)
+    t.join # server is connected to client
+  end
+
+end

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification
+name: url_tracker
+version: !ruby/object:Gem::Version
+  version: '0.1'
+  prerelease: 
+platform: ruby
+authors:
+- Renato Mascarenhas
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-06-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: libnotify
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: notifier
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A simple tool for tracking URLs and getting informed when they are changed.
+email: renato.mascosta@gmail.com
+executables:
+- ut
+- utd
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/url_tracker.rb
+- bin/ut
+- bin/utd
+- test/test_server.rb
+- test/test_periodic.rb
+- test/test_socket_communication.rb
+- test/test_client.rb
+- test/test_page.rb
+- test/test_helper.rb
+homepage: 
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -2248500158094718750
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -2248500158094718750
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: A simple tool for tracking URLs and getting informed when they are changed.
+test_files: []