IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Jun 29, 2005, 4:35:06 PM (21 years ago)
Author:
jhoblitt
Message:

rename PS::IPP::IData -> Nebulous

Location:
trunk/Nebulous-Server/t
Files:
26 edited

Legend:

Unmodified
Added
Removed

  • trunk/Nebulous-Server/t/01_load.t

    r4436 r4440  
    33# Copryight (C) 2004-2005  Joshua Hoblitt
    44#
    5 # $Id: 01_load.t,v 1.6 2005-06-30 01:37:16 jhoblitt Exp $
     5# $Id: 01_load.t,v 1.7 2005-06-30 02:35:06 jhoblitt Exp $
    66
    77use strict;
    … …  
    1212use Test::More tests => 8;
    1313
    14 BEGIN { use_ok( 'PS::IPP::IData::Client' ); }
    15 BEGIN { use_ok( 'PS::IPP::IData::Client::Log' ); }
    16 BEGIN { use_ok( 'PS::IPP::IData::Client::HTTP' ); }
    17 BEGIN { use_ok( 'PS::IPP::IData::Util' ); }
    18 BEGIN { use_ok( 'PS::IPP::IData::Server' ); }
    19 BEGIN { use_ok( 'PS::IPP::IData::Server::SQL' ); }
    20 BEGIN { use_ok( 'PS::IPP::IData::Server::Log' ); }
    21 BEGIN { use_ok( 'PS::IPP::IData::Server::SOAP' ); }
     14BEGIN { use_ok( 'Nebulous::Client' ); }
     15BEGIN { use_ok( 'Nebulous::Client::Log' ); }
     16BEGIN { use_ok( 'Nebulous::Client::HTTP' ); }
     17BEGIN { use_ok( 'Nebulous::Util' ); }
     18BEGIN { use_ok( 'Nebulous::Server' ); }
     19BEGIN { use_ok( 'Nebulous::Server::SQL' ); }
     20BEGIN { use_ok( 'Nebulous::Server::Log' ); }
     21BEGIN { use_ok( 'Nebulous::Server::SOAP' ); }

  • trunk/Nebulous-Server/t/02_server_setup.t

    r2872 r4440  
    33# Copryight (C) 2004-2005  Joshua Hoblitt
    44#
    5 # $Id: 02_server_setup.t,v 1.2 2005-01-03 23:55:29 jhoblitt Exp $
     5# $Id: 02_server_setup.t,v 1.3 2005-06-30 02:35:06 jhoblitt Exp $
    66
    77use strict;
    … …  
    1212use lib qw( ./t ./lib );
    1313
    14 use PS::IPP::IData::Server;
    15 use Test::IData;
     14use Nebulous::Server;
     15use Test::Nebulous;
    1616
    17 Test::IData->setup;
     17Test::Nebulous->setup;
    1818
    1919ok(
    20     PS::IPP::IData::Server->setup(
     20    Nebulous::Server->setup(
    2121        "DBI:mysql:database=test:host=localhost",
    2222        "test",
    … …  
    2626);
    2727
    28 Test::IData->setup;
     28Test::Nebulous->setup;
    2929
    3030eval {
    31     PS::IPP::IData::Server->setup(
     31    Nebulous::Server->setup(
    3232        "DBI:mysql:database=foobar:host=localhost",
    3333        "baz",
    … …  
    3737like( $@, qr/DBI connect.*? failed/, "bad dsn/user/pass" );
    3838
    39 Test::IData->cleanup;
     39Test::Nebulous->cleanup;

  • trunk/Nebulous-Server/t/03_server_create_object.t

    r2872 r4440  
    33# Copryight (C) 2004-2005  Joshua Hoblitt
    44#
    5 # $Id: 03_server_create_object.t,v 1.3 2005-01-03 23:55:29 jhoblitt Exp $
     5# $Id: 03_server_create_object.t,v 1.4 2005-06-30 02:35:06 jhoblitt Exp $
    66
    77use strict;
    … …  
    1212use lib qw( ./t ./lib );
    1313
    14 use PS::IPP::IData::Server;
    15 use PS::IPP::IData::Util qw( :standard );
    16 use Test::IData;
     14use Nebulous::Server;
     15use Nebulous::Util qw( :standard );
     16use Test::Nebulous;
    1717
    18 my $idata = "PS::IPP::IData::Server";
     18my $neb = "Nebulous::Server";
    1919
    20 $idata->setup(
     20$neb->setup(
    2121    "DBI:mysql:database=test:host=localhost",
    2222    "test",
    … …  
    2424);
    2525
    26 Test::IData->setup;
     26Test::Nebulous->setup;
    2727
    2828{
    2929    # key
    30     my $uri = $idata->create_object( "foo" );
     30    my $uri = $neb->create_object( "foo" );
    3131
    3232    ok( -e _get_file_path( $uri ), "file exists" );
    … …  
    3434}
    3535
    36 Test::IData->setup;
     36Test::Nebulous->setup;
    3737
    3838{
    3939    # key, class
    40     my $uri = $idata->create_object( "foo", 0 );
     40    my $uri = $neb->create_object( "foo", 0 );
    4141
    4242    ok( -e _get_file_path( $uri ), "file exists" );
    … …  
    4444}
    4545
    46 Test::IData->setup;
     46Test::Nebulous->setup;
    4747
    4848{
    4949    # key, class, volume
    50     my $uri = $idata->create_object( "foo", 0, "node01" );
     50    my $uri = $neb->create_object( "foo", 0, "node01" );
    5151
    5252    ok( -e _get_file_path( $uri ), "file exists" );
    … …  
    5454}
    5555
    56 Test::IData->setup;
     56Test::Nebulous->setup;
    5757
    5858{
    5959    # key, class, volume, comment
    60     my $uri = $idata->create_object( "foo", 0, "node01", "this is foo" );
     60    my $uri = $neb->create_object( "foo", 0, "node01", "this is foo" );
    6161
    6262    ok( -e _get_file_path( $uri ), "file exists" );
    … …  
    6464}
    6565
    66 Test::IData->setup;
     66Test::Nebulous->setup;
    6767
    6868eval {
    69     $idata->create_object( "foo" );
    70     $idata->create_object( "foo" );
     69    $neb->create_object( "foo" );
     70    $neb->create_object( "foo" );
    7171};
    7272like( $@, qr/Duplicate entry/, "object already exists" );
    7373
    74 Test::IData->setup;
     74Test::Nebulous->setup;
    7575
    7676eval {
    77     $idata->create_object();
     77    $neb->create_object();
    7878};
    7979like( $@, qr/2 - 4 were expected/, "no params" );
    8080
    81 Test::IData->setup;
     81Test::Nebulous->setup;
    8282
    8383eval {
    84     $idata->create_object( 1, 2, 3, 4, 5 );
     84    $neb->create_object( 1, 2, 3, 4, 5 );
    8585};
    8686like( $@, qr/2 - 4 were expected/, "too many params" );
    8787
    88 Test::IData->cleanup;
     88Test::Nebulous->cleanup;

  • trunk/Nebulous-Server/t/04_server_replicate_object.t

    r2872 r4440  
    33# Copryight (C) 2004-2005  Joshua Hoblitt
    44#
    5 # $Id: 04_server_replicate_object.t,v 1.3 2005-01-03 23:55:29 jhoblitt Exp $
     5# $Id: 04_server_replicate_object.t,v 1.4 2005-06-30 02:35:06 jhoblitt Exp $
    66
    77use strict;
    … …  
    1212use lib qw( ./t ./lib );
    1313
    14 use PS::IPP::IData::Server;
    15 use PS::IPP::IData::Util qw( :standard );
    16 use Test::IData;
     14use Nebulous::Server;
     15use Nebulous::Util qw( :standard );
     16use Test::Nebulous;
    1717
    18 my $idata = "PS::IPP::IData::Server";
     18my $neb = "Nebulous::Server";
    1919
    20 $idata->setup(
     20$neb->setup(
    2121    "DBI:mysql:database=test:host=localhost",
    2222    "test",
    … …  
    2424);
    2525
    26 Test::IData->setup;
     26Test::Nebulous->setup;
    2727
    2828{
    2929    # key
    30     $idata->create_object( "foo" );
    31     my $uri = $idata->replicate_object( "foo" );
     30    $neb->create_object( "foo" );
     31    my $uri = $neb->replicate_object( "foo" );
    3232
    3333    ok( -e _get_file_path( $uri ), "file exists" );
    … …  
    3535}
    3636
    37 Test::IData->setup;
     37Test::Nebulous->setup;
    3838
    3939{
    4040    # key, $volume
    41     $idata->create_object( "foo" );
    42     my $uri = $idata->replicate_object( "foo", "node01" );
     41    $neb->create_object( "foo" );
     42    my $uri = $neb->replicate_object( "foo", "node01" );
    4343
    4444    ok( -e _get_file_path( $uri ), "file exists" );
    … …  
    4646}
    4747
    48 Test::IData->setup;
     48Test::Nebulous->setup;
    4949
    5050{
    5151    # key, $volume
    52     $idata->create_object( "foo" );
    53     my $uri1 = $idata->replicate_object( "foo", "node01" );
    54     my $uri2 = $idata->replicate_object( "foo", "node02" );
     52    $neb->create_object( "foo" );
     53    my $uri1 = $neb->replicate_object( "foo", "node01" );
     54    my $uri2 = $neb->replicate_object( "foo", "node02" );
    5555
    5656    ok( -e _get_file_path( $uri1 ), "file exists" );
    … …  
    6060}
    6161
    62 Test::IData->setup;
     62Test::Nebulous->setup;
    6363
    6464eval {
    65     $idata->replicate_object( "foo" );
     65    $neb->replicate_object( "foo" );
    6666};
    6767like( $@, qr/storage object does not exist/, "storage object does not exist" );
    6868
    69 Test::IData->setup;
     69Test::Nebulous->setup;
    7070
    7171eval {
    72     $idata->replicate_object();
     72    $neb->replicate_object();
    7373};
    7474like( $@, qr/1 - 2 were expected/, "no params" );
    7575
    76 Test::IData->setup;
     76Test::Nebulous->setup;
    7777
    7878eval {
    79     $idata->replicate_object( 1, 2, 3 );
     79    $neb->replicate_object( 1, 2, 3 );
    8080};
    8181like( $@, qr/1 - 2 were expected/, "too many params" );
    8282
    83 Test::IData->cleanup;
     83Test::Nebulous->cleanup;

  • trunk/Nebulous-Server/t/05_server_lock_object.t

    r2872 r4440  
    33# Copryight (C) 2004-2005  Joshua Hoblitt
    44#
    5 # $Id: 05_server_lock_object.t,v 1.3 2005-01-03 23:55:29 jhoblitt Exp $
     5# $Id: 05_server_lock_object.t,v 1.4 2005-06-30 02:35:06 jhoblitt Exp $
    66
    77use strict;
    … …  
    1212use lib qw( ./t ./lib );
    1313
    14 use PS::IPP::IData::Server;
    15 use PS::IPP::IData::Util qw( :standard );
    16 use Test::IData;
     14use Nebulous::Server;
     15use Nebulous::Util qw( :standard );
     16use Test::Nebulous;
    1717
    18 my $idata = "PS::IPP::IData::Server";
     18my $neb = "Nebulous::Server";
    1919
    20 $idata->setup(
     20$neb->setup(
    2121    "DBI:mysql:database=test:host=localhost",
    2222    "test",
    … …  
    2424);
    2525
    26 Test::IData->setup;
     26Test::Nebulous->setup;
    2727
    2828{
    29     $idata->create_object( "foo" );
     29    $neb->create_object( "foo" );
    3030
    31     ok( $idata->lock_object( "foo", "read" ), "read lock" );
     31    ok( $neb->lock_object( "foo", "read" ), "read lock" );
    3232}
    3333
    34 Test::IData->setup;
     34Test::Nebulous->setup;
    3535
    3636{
    37     $idata->create_object( "foo" );
     37    $neb->create_object( "foo" );
    3838
    39     ok( $idata->lock_object( "foo", "read" ), "read lock" );
    40     ok( $idata->lock_object( "foo", "read" ), "read lock" );
     39    ok( $neb->lock_object( "foo", "read" ), "read lock" );
     40    ok( $neb->lock_object( "foo", "read" ), "read lock" );
    4141}
    4242
    43 Test::IData->setup;
     43Test::Nebulous->setup;
    4444
    4545{
    46     $idata->create_object( "foo" );
     46    $neb->create_object( "foo" );
    4747
    48     ok( $idata->lock_object( "foo", "write" ), "write lock" );
     48    ok( $neb->lock_object( "foo", "write" ), "write lock" );
    4949}
    5050
    51 Test::IData->setup;
     51Test::Nebulous->setup;
    5252
    5353eval {
    54     $idata->lock_object( "foo", "read" );
     54    $neb->lock_object( "foo", "read" );
    5555};
    5656like( $@, qr/storage object does not exist/, "storage object does not exist" );
    5757
    58 Test::IData->setup;
     58Test::Nebulous->setup;
    5959
    6060eval {
    61     $idata->lock_object( "foo", "write" );
     61    $neb->lock_object( "foo", "write" );
    6262};
    6363like( $@, qr/storage object does not exist/, "storage object does not exist" );
    6464
    65 Test::IData->setup;
     65Test::Nebulous->setup;
    6666
    6767eval {
    68     $idata->create_object( "foo" );
     68    $neb->create_object( "foo" );
    6969
    70     $idata->lock_object( "foo", "write" );
    71     $idata->lock_object( "foo", "write" );
     70    $neb->lock_object( "foo", "write" );
     71    $neb->lock_object( "foo", "write" );
    7272};
    7373like( $@, qr/can not write lock twice/, "can not write lock twice" );
    7474
    75 Test::IData->setup;
     75Test::Nebulous->setup;
    7676
    7777eval {
    78     $idata->create_object( "foo" );
     78    $neb->create_object( "foo" );
    7979
    80     $idata->lock_object( "foo", "read" );
    81     $idata->lock_object( "foo", "write" );
     80    $neb->lock_object( "foo", "read" );
     81    $neb->lock_object( "foo", "write" );
    8282};
    8383like( $@, qr/can not write lock after read lock/, "can not write lock after read lock" );
    8484
    85 Test::IData->setup;
     85Test::Nebulous->setup;
    8686
    8787eval {
    88     $idata->create_object( "foo" );
     88    $neb->create_object( "foo" );
    8989
    90     $idata->lock_object( "foo", "write" );
    91     $idata->lock_object( "foo", "read" );
     90    $neb->lock_object( "foo", "write" );
     91    $neb->lock_object( "foo", "read" );
    9292};
    9393like( $@, qr/can not read lock after write lock/, "can not read lock after write lock" );
    9494
    95 Test::IData->setup;
     95Test::Nebulous->setup;
    9696
    9797eval {
    98     $idata->lock_object();
     98    $neb->lock_object();
    9999};
    100100like( $@, qr/2 were expected/, "no params" );
    101101
    102 Test::IData->setup;
     102Test::Nebulous->setup;
    103103
    104104eval {
    105     $idata->lock_object( "foo" );
     105    $neb->lock_object( "foo" );
    106106};
    107107like( $@, qr/2 were expected/, "not enough params" );
    108108
    109 Test::IData->setup;
     109Test::Nebulous->setup;
    110110
    111111eval {
    112     $idata->lock_object( "foo", "both" );
     112    $neb->lock_object( "foo", "both" );
    113113};
    114114like( $@, qr/is read or write/, "not read or write" );
    115115
    116 Test::IData->setup;
     116Test::Nebulous->setup;
    117117
    118118eval {
    119     $idata->lock_object( "foo", 'read', 3 );
     119    $neb->lock_object( "foo", 'read', 3 );
    120120};
    121121like( $@, qr/2 were expected/, "too many params" );
    122122
    123 Test::IData->cleanup;
     123Test::Nebulous->cleanup;

  • trunk/Nebulous-Server/t/06_server_unlock_object.t

    r2872 r4440  
    33# Copryight (C) 2004-2005  Joshua Hoblitt
    44#
    5 # $Id: 06_server_unlock_object.t,v 1.3 2005-01-03 23:55:29 jhoblitt Exp $
     5# $Id: 06_server_unlock_object.t,v 1.4 2005-06-30 02:35:06 jhoblitt Exp $
    66
    77use strict;
    … …  
    1212use lib qw( ./t ./lib );
    1313
    14 use PS::IPP::IData::Server;
    15 use PS::IPP::IData::Util qw( :standard );
    16 use Test::IData;
     14use Nebulous::Server;
     15use Nebulous::Util qw( :standard );
     16use Test::Nebulous;
    1717
    18 my $idata = "PS::IPP::IData::Server";
     18my $neb = "Nebulous::Server";
    1919
    20 $idata->setup(
     20$neb->setup(
    2121    "DBI:mysql:database=test:host=localhost",
    2222    "test",
    … …  
    2424);
    2525
    26 Test::IData->setup;
     26Test::Nebulous->setup;
    2727
    2828{
    29     $idata->create_object( "foo" );
     29    $neb->create_object( "foo" );
    3030
    31     $idata->lock_object( "foo", "read" );
     31    $neb->lock_object( "foo", "read" );
    3232
    33     ok( $idata->unlock_object( "foo", "read" ), "read unlock" );
     33    ok( $neb->unlock_object( "foo", "read" ), "read unlock" );
    3434}
    3535
    36 Test::IData->setup;
     36Test::Nebulous->setup;
    3737
    3838{
    39     $idata->create_object( "foo" );
     39    $neb->create_object( "foo" );
    4040
    41     $idata->lock_object( "foo", "read" );
    42     $idata->lock_object( "foo", "read" );
     41    $neb->lock_object( "foo", "read" );
     42    $neb->lock_object( "foo", "read" );
    4343
    44     ok( $idata->unlock_object( "foo", "read" ), "read unlock" );
    45     ok( $idata->unlock_object( "foo", "read" ), "read unlock" );
     44    ok( $neb->unlock_object( "foo", "read" ), "read unlock" );
     45    ok( $neb->unlock_object( "foo", "read" ), "read unlock" );
    4646}
    4747
    48 Test::IData->setup;
     48Test::Nebulous->setup;
    4949
    5050{
    51     $idata->create_object( "foo" );
     51    $neb->create_object( "foo" );
    5252
    53     $idata->lock_object( "foo", "write" );
     53    $neb->lock_object( "foo", "write" );
    5454
    55     ok( $idata->unlock_object( "foo", "write" ), "write unlock" );
     55    ok( $neb->unlock_object( "foo", "write" ), "write unlock" );
    5656}
    5757
    58 Test::IData->setup;
     58Test::Nebulous->setup;
    5959
    6060eval {
    61     $idata->unlock_object( "foo", "read" );
     61    $neb->unlock_object( "foo", "read" );
    6262};
    6363like( $@, qr/storage object does not exist/, "storage object does not exist" );
    6464
    65 Test::IData->setup;
     65Test::Nebulous->setup;
    6666
    6767eval {
    68     $idata->unlock_object( "foo", "write" );
     68    $neb->unlock_object( "foo", "write" );
    6969};
    7070like( $@, qr/storage object does not exist/, "storage object does not exist" );
    7171
    72 Test::IData->setup;
     72Test::Nebulous->setup;
    7373
    7474eval {
    75     $idata->create_object( "foo" );
     75    $neb->create_object( "foo" );
    7676
    77     $idata->unlock_object( "foo", "read" );
     77    $neb->unlock_object( "foo", "read" );
    7878};
    7979like( $@, qr/can not remove non-existant read lock/, "no lock set" );
    8080
    81 Test::IData->setup;
     81Test::Nebulous->setup;
    8282
    8383eval {
    84     $idata->create_object( "foo" );
     84    $neb->create_object( "foo" );
    8585
    86     $idata->unlock_object( "foo", "write" );
     86    $neb->unlock_object( "foo", "write" );
    8787};
    8888like( $@, qr/can not remove non-existant write lock/, "no lock set" );
    8989
    90 Test::IData->setup;
     90Test::Nebulous->setup;
    9191
    9292eval {
    93     $idata->create_object( "foo" );
    94     $idata->lock_object( "foo", "write" );
     93    $neb->create_object( "foo" );
     94    $neb->lock_object( "foo", "write" );
    9595
    96     $idata->unlock_object( "foo", "read" );
     96    $neb->unlock_object( "foo", "read" );
    9797};
    9898like( $@, qr/can not have a read lock under a write lock/, "read unlock under write lock" );
    9999
    100 Test::IData->setup;
     100Test::Nebulous->setup;
    101101
    102102eval {
    103     $idata->create_object( "foo" );
    104     $idata->lock_object( "foo", "read" );
     103    $neb->create_object( "foo" );
     104    $neb->lock_object( "foo", "read" );
    105105
    106     $idata->unlock_object( "foo", "write" );
     106    $neb->unlock_object( "foo", "write" );
    107107};
    108108like( $@, qr/can not have a write lock under a read lock/, "write unlock under read lock" );
    109109
    110 Test::IData->setup;
     110Test::Nebulous->setup;
    111111
    112112eval {
    113     $idata->unlock_object();
     113    $neb->unlock_object();
    114114};
    115115like( $@, qr/2 were expected/, "no params" );
    116116
    117 Test::IData->setup;
     117Test::Nebulous->setup;
    118118
    119119eval {
    120     $idata->unlock_object( "foo" );
     120    $neb->unlock_object( "foo" );
    121121};
    122122like( $@, qr/2 were expected/, "not enough params" );
    123123
    124 Test::IData->setup;
     124Test::Nebulous->setup;
    125125
    126126eval {
    127     $idata->unlock_object( "foo", "both" );
     127    $neb->unlock_object( "foo", "both" );
    128128};
    129129like( $@, qr/is read or write/, "not read or write" );
    130130
    131 Test::IData->setup;
     131Test::Nebulous->setup;
    132132
    133133eval {
    134     $idata->unlock_object( "foo", 'read', 3 );
     134    $neb->unlock_object( "foo", 'read', 3 );
    135135};
    136136like( $@, qr/2 were expected/, "too many params" );
    137137
    138 Test::IData->cleanup;
     138Test::Nebulous->cleanup;

  • trunk/Nebulous-Server/t/07_server_find_instances.t

    r2872 r4440  
    33# Copryight (C) 2004-2005  Joshua Hoblitt
    44#
    5 # $Id: 07_server_find_instances.t,v 1.3 2005-01-03 23:55:29 jhoblitt Exp $
     5# $Id: 07_server_find_instances.t,v 1.4 2005-06-30 02:35:06 jhoblitt Exp $
    66
    77use strict;
    … …  
    1212use lib qw( ./t ./lib );
    1313
    14 use PS::IPP::IData::Server;
    15 use PS::IPP::IData::Util qw( :standard );
    16 use Test::IData;
     14use Nebulous::Server;
     15use Nebulous::Util qw( :standard );
     16use Test::Nebulous;
    1717
    18 my $idata = "PS::IPP::IData::Server";
     18my $neb = "Nebulous::Server";
    1919
    20 $idata->setup(
     20$neb->setup(
    2121    "DBI:mysql:database=test:host=localhost",
    2222    "test",
    … …  
    2424);
    2525
    26 Test::IData->setup;
     26Test::Nebulous->setup;
    2727
    2828{
    2929    # key
    30     my $uri = $idata->create_object( "foo" );
     30    my $uri = $neb->create_object( "foo" );
    3131
    32     my $locations = $idata->find_instances( "foo" );
     32    my $locations = $neb->find_instances( "foo" );
    3333
    3434    is( $uri, $locations->[0], "URIs match" );
    3535}
    3636
    37 Test::IData->setup;
     37Test::Nebulous->setup;
    3838
    3939{
    4040    # key
    41     my $uri1 = $idata->create_object( "foo" );
    42     my $uri2 = $idata->replicate_object( "foo" );
     41    my $uri1 = $neb->create_object( "foo" );
     42    my $uri2 = $neb->replicate_object( "foo" );
    4343
    44     my $locations = $idata->find_instances( "foo" );
     44    my $locations = $neb->find_instances( "foo" );
    4545
    4646    ok( eq_set( [$uri1, $uri2], $locations ), "URIs match" );
    4747}
    4848
    49 Test::IData->setup;
     49Test::Nebulous->setup;
    5050
    5151{
    5252    # key, volume
    53     my $uri = $idata->create_object( "foo" );
     53    my $uri = $neb->create_object( "foo" );
    5454
    55     my $locations = $idata->find_instances( "foo", "node01" );
     55    my $locations = $neb->find_instances( "foo", "node01" );
    5656
    5757    is( $uri, $locations->[0], "URIs match" );
    5858}
    5959
    60 Test::IData->setup;
     60Test::Nebulous->setup;
    6161
    6262{
    6363    # key
    64     my $uri1 = $idata->create_object( "foo" );
    65     my $uri2 = $idata->replicate_object( "foo" );
     64    my $uri1 = $neb->create_object( "foo" );
     65    my $uri2 = $neb->replicate_object( "foo" );
    6666
    67     my $locations = $idata->find_instances( "foo", "node01" );
     67    my $locations = $neb->find_instances( "foo", "node01" );
    6868
    6969    ok( eq_set( [$uri1, $uri2], $locations ), "URIs match" );
    … …  
    7171
    7272
    73 Test::IData->setup;
     73Test::Nebulous->setup;
    7474
    7575eval {
    76     $idata->find_instances( "foo" );
     76    $neb->find_instances( "foo" );
    7777};
    7878like( $@, qr/no instances found/, "storage object does not exist" );
    7979
    80 Test::IData->setup;
     80Test::Nebulous->setup;
    8181
    8282eval {
    83     $idata->find_instances();
     83    $neb->find_instances();
    8484};
    8585like( $@, qr/1 - 2 were expected/, "no params" );
    8686
    87 Test::IData->setup;
     87Test::Nebulous->setup;
    8888
    8989eval {
    90     $idata->find_instances( "foo", 'read', 3 );
     90    $neb->find_instances( "foo", 'read', 3 );
    9191};
    9292like( $@, qr/1 - 2 were expected/, "too many params" );
    9393
    94 Test::IData->cleanup;
     94Test::Nebulous->cleanup;

  • trunk/Nebulous-Server/t/08_server_delete_instance.t

    r2872 r4440  
    33# Copryight (C) 2004-2005  Joshua Hoblitt
    44#
    5 # $Id: 08_server_delete_instance.t,v 1.3 2005-01-03 23:55:29 jhoblitt Exp $
     5# $Id: 08_server_delete_instance.t,v 1.4 2005-06-30 02:35:06 jhoblitt Exp $
    66
    77use strict;
    … …  
    1212use lib qw( ./t ./lib );
    1313
    14 use PS::IPP::IData::Server;
    15 use PS::IPP::IData::Util qw( :standard );
    16 use Test::IData;
     14use Nebulous::Server;
     15use Nebulous::Util qw( :standard );
     16use Test::Nebulous;
    1717
    18 my $idata = "PS::IPP::IData::Server";
     18my $neb = "Nebulous::Server";
    1919
    20 $idata->setup(
     20$neb->setup(
    2121    "DBI:mysql:database=test:host=localhost",
    2222    "test",
    … …  
    2424);
    2525
    26 Test::IData->setup;
     26Test::Nebulous->setup;
    2727
    2828{
    29     my $uri = $idata->create_object( "foo" );
     29    my $uri = $neb->create_object( "foo" );
    3030
    31     ok( $idata->delete_instance( $uri ), "delete instance" );
     31    ok( $neb->delete_instance( $uri ), "delete instance" );
    3232}
    3333
    34 Test::IData->setup;
     34Test::Nebulous->setup;
    3535
    3636{
    37     my $uri1 = $idata->create_object( "foo" );
    38     my $uri2 = $idata->replicate_object( "foo" );
     37    my $uri1 = $neb->create_object( "foo" );
     38    my $uri2 = $neb->replicate_object( "foo" );
    3939
    40     ok( $idata->delete_instance( $uri1 ), "delete instance" );
     40    ok( $neb->delete_instance( $uri1 ), "delete instance" );
    4141
    42     my $locations = $idata->find_instances( "foo" );
     42    my $locations = $neb->find_instances( "foo" );
    4343
    4444    is( $locations->[0], $uri2, "instance remains" );
    4545
    46     ok( $idata->delete_instance( $uri2 ), "delete instance" );
     46    ok( $neb->delete_instance( $uri2 ), "delete instance" );
    4747
    4848    eval {
    49         $idata->find_instances( "foo" );
     49        $neb->find_instances( "foo" );
    5050    };
    5151    like( $@, qr/no instances found/, "storage object was deleted" );
    5252}
    5353
    54 Test::IData->setup;
     54Test::Nebulous->setup;
    5555
    5656eval {
    57     $idata->delete_instance( "file:/foo" );
     57    $neb->delete_instance( "file:/foo" );
    5858};
    5959like( $@, qr/no instance is associated with uri/, "uri does not exist" );
    6060
    61 Test::IData->setup;
     61Test::Nebulous->setup;
    6262
    6363eval {
    64     $idata->delete_instance();
     64    $neb->delete_instance();
    6565};
    6666like( $@, qr/1 was expected/, "no params" );
    6767
    68 Test::IData->setup;
     68Test::Nebulous->setup;
    6969
    7070eval {
    71     $idata->delete_instance( "foo", 2 );
     71    $neb->delete_instance( "foo", 2 );
    7272};
    7373like( $@, qr/1 was expected/, "too many params" );
    7474
    75 Test::IData->cleanup;
     75Test::Nebulous->cleanup;

  • trunk/Nebulous-Server/t/09_server_stat_object.t

    r3016 r4440  
    33# Copryight (C) 2004-2005  Joshua Hoblitt
    44#
    5 # $Id: 09_server_stat_object.t,v 1.4 2005-01-15 04:02:12 jhoblitt Exp $
     5# $Id: 09_server_stat_object.t,v 1.5 2005-06-30 02:35:06 jhoblitt Exp $
    66
    77use strict;
    … …  
    1212use lib qw( ./t ./lib );
    1313
    14 use PS::IPP::IData::Server;
    15 use PS::IPP::IData::Util qw( :standard );
    16 use Test::IData;
     14use Nebulous::Server;
     15use Nebulous::Util qw( :standard );
     16use Test::Nebulous;
    1717
    18 my $idata = "PS::IPP::IData::Server";
     18my $neb = "Nebulous::Server";
    1919
    20 $idata->setup(
     20$neb->setup(
    2121    "DBI:mysql:database=test:host=localhost",
    2222    "test",
    … …  
    2424);
    2525
    26 Test::IData->setup;
     26Test::Nebulous->setup;
    2727
    2828{
    29     my $uri = $idata->create_object( "foo" );
     29    my $uri = $neb->create_object( "foo" );
    3030
    31     my $info = $idata->stat_object( "foo" );
     31    my $info = $neb->stat_object( "foo" );
    3232
    3333    is( scalar @$info, 8, "number of columns" );
    3434}
    3535
    36 Test::IData->setup;
     36Test::Nebulous->setup;
    3737
    3838{
    39     my $uri = $idata->create_object( "foo", 9, "node01", "foobar" );
     39    my $uri = $neb->create_object( "foo", 9, "node01", "foobar" );
    4040
    41     my $info = $idata->stat_object( "foo" );
     41    my $info = $neb->stat_object( "foo" );
    4242
    4343    is( scalar @$info, 8,                       "number of columns" );
    … …  
    5252}
    5353
    54 Test::IData->setup;
     54Test::Nebulous->setup;
    5555
    5656eval {
    57     $idata->stat_object( "foo" );
     57    $neb->stat_object( "foo" );
    5858};
    5959like( $@, qr/no storage object found/, "object does not exist" );
    6060
    61 Test::IData->setup;
     61Test::Nebulous->setup;
    6262
    6363eval {
    64     $idata->stat_object();
     64    $neb->stat_object();
    6565};
    6666like( $@, qr/1 was expected/, "no params" );
    6767
    68 Test::IData->setup;
     68Test::Nebulous->setup;
    6969
    7070eval {
    71     $idata->stat_object( "foo", 2 );
     71    $neb->stat_object( "foo", 2 );
    7272};
    7373like( $@, qr/1 was expected/, "too many params" );
    7474
    75 Test::IData->cleanup;
     75Test::Nebulous->cleanup;

  • trunk/Nebulous-Server/t/10_client_new.t

    r2872 r4440  
    33# Copryight (C) 2004-2005  Joshua Hoblitt
    44#
    5 # $Id: 10_client_new.t,v 1.3 2005-01-03 23:55:29 jhoblitt Exp $
     5# $Id: 10_client_new.t,v 1.4 2005-06-30 02:35:06 jhoblitt Exp $
    66
    77use strict;
    … …  
    1414use lib qw( ./t ./lib );
    1515
    16 use PS::IPP::IData::Client;
    17 use PS::IPP::IData::Util qw( :standard );
    18 use Test::IData;
     16use Nebulous::Client;
     17use Nebulous::Util qw( :standard );
     18use Test::Nebulous;
    1919
    2020my $hostport = Apache::Test->config->{ 'hostport' };
    2121
    22 Test::IData->setup;
     22Test::Nebulous->setup;
    2323
    2424{
    25     my $idata = PS::IPP::IData::Client->new(
    26         proxy => "http://$hostport/idata",
     25    my $neb = Nebulous::Client->new(
     26        proxy => "http://$hostport/nebulous",
    2727    );
    2828
    29     isa_ok( $idata, "PS::IPP::IData::Client" );
     29    isa_ok( $neb, "Nebulous::Client" );
    3030}
    3131
    32 Test::IData->setup;
     32Test::Nebulous->setup;
    3333
    3434{
    35     my $idata = PS::IPP::IData::Client->new(
    36         proxy => "http://$hostport/idata",
    37         uri   => "http://example.com/PS/IPP/IData/Client",
     35    my $neb = Nebulous::Client->new(
     36        proxy => "http://$hostport/nebulous",
     37        uri   => "http://example.com/PS/IPP/Nebulous/Client",
    3838    );
    3939
    40     isa_ok( $idata, "PS::IPP::IData::Client" );
     40    isa_ok( $neb, "Nebulous::Client" );
    4141}
    4242
    43 Test::IData->setup;
     43Test::Nebulous->setup;
    4444
    4545eval {
    46     PS::IPP::IData::Client->new;
     46    Nebulous::Client->new;
    4747};
    4848like( $@, qr/Mandatory parameter/, "no proxy" );
    4949
    50 Test::IData->setup;
     50Test::Nebulous->setup;
    5151
    5252eval {
    53     PS::IPP::IData::Client->new(
     53    Nebulous::Client->new(
    5454        proxy => "foo",
    5555        dog => "do"
    … …  
    5858like( $@, qr/not listed in the validation options/, "bad param" );
    5959
    60 Test::IData->cleanup;
     60Test::Nebulous->cleanup;

  • trunk/Nebulous-Server/t/11_client_create.t

    r2872 r4440  
    33# Copryight (C) 2004-2005  Joshua Hoblitt
    44#
    5 # $Id: 11_client_create.t,v 1.3 2005-01-03 23:55:29 jhoblitt Exp $
     5# $Id: 11_client_create.t,v 1.4 2005-06-30 02:35:06 jhoblitt Exp $
    66
    77use strict;
    … …  
    1414use lib qw( ./t ./lib );
    1515
    16 use PS::IPP::IData::Client;
    17 use PS::IPP::IData::Util qw( :standard );
    18 use Test::IData;
     16use Nebulous::Client;
     17use Nebulous::Util qw( :standard );
     18use Test::Nebulous;
    1919
    2020my $hostport = Apache::Test->config->{ 'hostport' };
    2121
    22 Test::IData->setup;
     22Test::Nebulous->setup;
    2323
    2424{
    2525    # key
    26     my $idata = PS::IPP::IData::Client->new(
    27         proxy => "http://$hostport/idata",
     26    my $neb = Nebulous::Client->new(
     27        proxy => "http://$hostport/nebulous",
    2828    );
    2929
    30     my $fh = $idata->create( "foo" );
     30    my $fh = $neb->create( "foo" );
    3131
    3232    is( ref $fh, 'GLOB', "good filehandle" );
    3333}
    3434
    35 Test::IData->setup;
     35Test::Nebulous->setup;
    3636
    3737{
    3838    # key, class
    39     my $idata = PS::IPP::IData::Client->new(
    40         proxy => "http://$hostport/idata",
     39    my $neb = Nebulous::Client->new(
     40        proxy => "http://$hostport/nebulous",
    4141    );
    4242
    43     my $fh = $idata->create( "foo", 0 );
     43    my $fh = $neb->create( "foo", 0 );
    4444
    4545    is( ref $fh, 'GLOB', "good filehandle" );
    4646}
    4747
    48 Test::IData->setup;
     48Test::Nebulous->setup;
    4949
    5050{
    5151    # key, class, volume
    52     my $idata = PS::IPP::IData::Client->new(
    53         proxy => "http://$hostport/idata",
     52    my $neb = Nebulous::Client->new(
     53        proxy => "http://$hostport/nebulous",
    5454    );
    5555
    56     my $fh = $idata->create( "foo", 0, "node01" );
     56    my $fh = $neb->create( "foo", 0, "node01" );
    5757
    5858    is( ref $fh, 'GLOB', "good filehandle" );
    5959}
    6060
    61 Test::IData->setup;
     61Test::Nebulous->setup;
    6262
    6363{
    6464    # key, class, volume, comment
    65     my $idata = PS::IPP::IData::Client->new(
    66         proxy => "http://$hostport/idata",
     65    my $neb = Nebulous::Client->new(
     66        proxy => "http://$hostport/nebulous",
    6767    );
    6868
    69     my $fh = $idata->create( "foo", 0, "node01", "this is foo" );
     69    my $fh = $neb->create( "foo", 0, "node01", "this is foo" );
    7070
    7171    is( ref $fh, 'GLOB', "good filehandle" );
    7272}
    7373
    74 Test::IData->setup;
     74Test::Nebulous->setup;
    7575
    7676{
    77     my $idata = PS::IPP::IData::Client->new(
    78         proxy => "http://$hostport/idata",
     77    my $neb = Nebulous::Client->new(
     78        proxy => "http://$hostport/nebulous",
    7979    );
    8080
    81     $idata->create( "foo" );
    82     is( $idata->create( "foo" ), undef, "object already exists" );
     81    $neb->create( "foo" );
     82    is( $neb->create( "foo" ), undef, "object already exists" );
    8383}
    8484
    85 Test::IData->setup;
     85Test::Nebulous->setup;
    8686
    8787eval {
    88     my $idata = PS::IPP::IData::Client->new(
    89         proxy => "http://$hostport/idata",
     88    my $neb = Nebulous::Client->new(
     89        proxy => "http://$hostport/nebulous",
    9090    );
    9191
    92     $idata->create();
     92    $neb->create();
    9393};
    9494like( $@, qr/2 - 4 were expected/, "no params" );
    9595
    96 Test::IData->setup;
     96Test::Nebulous->setup;
    9797
    9898eval {
    99     my $idata = PS::IPP::IData::Client->new(
    100         proxy => "http://$hostport/idata",
     99    my $neb = Nebulous::Client->new(
     100        proxy => "http://$hostport/nebulous",
    101101    );
    102102
    103     $idata->create( 1, 2, 3, 4, 5 );
     103    $neb->create( 1, 2, 3, 4, 5 );
    104104};
    105105like( $@, qr/2 - 4 were expected/, "too many params" );
    106106
    107 Test::IData->cleanup;
     107Test::Nebulous->cleanup;

  • trunk/Nebulous-Server/t/12_client_replicate.t

    r2872 r4440  
    33# Copryight (C) 2004-2005  Joshua Hoblitt
    44#
    5 # $Id: 12_client_replicate.t,v 1.3 2005-01-03 23:55:29 jhoblitt Exp $
     5# $Id: 12_client_replicate.t,v 1.4 2005-06-30 02:35:06 jhoblitt Exp $
    66
    77use strict;
    … …  
    1414use lib qw( ./t ./lib );
    1515
    16 use PS::IPP::IData::Client;
    17 use PS::IPP::IData::Util qw( :standard );
    18 use Test::IData;
     16use Nebulous::Client;
     17use Nebulous::Util qw( :standard );
     18use Test::Nebulous;
    1919
    2020my $hostport = Apache::Test->config->{ 'hostport' };
    2121
    22 Test::IData->setup;
     22Test::Nebulous->setup;
    2323
    2424{
    2525    # key
    26     my $idata = PS::IPP::IData::Client->new(
    27         proxy => "http://$hostport/idata",
     26    my $neb = Nebulous::Client->new(
     27        proxy => "http://$hostport/nebulous",
    2828    );
    29     $idata->create( "foo" );
     29    $neb->create( "foo" );
    3030
    31     my $uri = $idata->replicate( "foo" );
     31    my $uri = $neb->replicate( "foo" );
    3232
    3333    ok( $uri, "good replication" );
    … …  
    3535}
    3636
    37 Test::IData->setup;
     37Test::Nebulous->setup;
    3838
    3939{
    4040    # key, $volume
    41     my $idata = PS::IPP::IData::Client->new(
    42         proxy => "http://$hostport/idata",
     41    my $neb = Nebulous::Client->new(
     42        proxy => "http://$hostport/nebulous",
    4343    );
    44     $idata->create( "foo" );
     44    $neb->create( "foo" );
    4545
    46     my $uri = $idata->replicate( "foo", "node01" );
     46    my $uri = $neb->replicate( "foo", "node01" );
    4747
    4848    ok( $uri, "good replication" );
    … …  
    5050}
    5151
    52 Test::IData->setup;
     52Test::Nebulous->setup;
    5353
    5454{
    5555    # key, $volume
    56     my $idata = PS::IPP::IData::Client->new(
    57         proxy => "http://$hostport/idata",
     56    my $neb = Nebulous::Client->new(
     57        proxy => "http://$hostport/nebulous",
    5858    );
    59     $idata->create( "foo" );
     59    $neb->create( "foo" );
    6060
    61     my $uri1 = $idata->replicate( "foo", "node01" );
    62     my $uri2 = $idata->replicate( "foo", "node02" );
     61    my $uri1 = $neb->replicate( "foo", "node01" );
     62    my $uri2 = $neb->replicate( "foo", "node02" );
    6363
    6464    ok( $uri1, "good replication" );
    … …  
    6868}
    6969
    70 Test::IData->setup;
     70Test::Nebulous->setup;
    7171
    7272{
    73     my $idata = PS::IPP::IData::Client->new(
    74         proxy => "http://$hostport/idata",
     73    my $neb = Nebulous::Client->new(
     74        proxy => "http://$hostport/nebulous",
    7575    );
    76     my $uri = $idata->replicate( "foo" );
     76    my $uri = $neb->replicate( "foo" );
    7777
    7878    is( $uri, undef, "storage object does not exist" );
    7979}
    8080
    81 Test::IData->setup;
     81Test::Nebulous->setup;
    8282
    8383eval {
    84     my $idata = PS::IPP::IData::Client->new(
    85         proxy => "http://$hostport/idata",
     84    my $neb = Nebulous::Client->new(
     85        proxy => "http://$hostport/nebulous",
    8686    );
    87     $idata->replicate();
     87    $neb->replicate();
    8888};
    8989like( $@, qr/1 - 2 were expected/, "no params" );
    9090
    91 Test::IData->setup;
     91Test::Nebulous->setup;
    9292
    9393eval {
    94     my $idata = PS::IPP::IData::Client->new(
    95         proxy => "http://$hostport/idata",
     94    my $neb = Nebulous::Client->new(
     95        proxy => "http://$hostport/nebulous",
    9696    );
    97     $idata->replicate( 1, 2, 3 );
     97    $neb->replicate( 1, 2, 3 );
    9898};
    9999like( $@, qr/1 - 2 were expected/, "too many params" );
    100100
    101 Test::IData->cleanup;
     101Test::Nebulous->cleanup;

  • trunk/Nebulous-Server/t/13_client_cull.t

    r2872 r4440  
    33# Copryight (C) 2004-2005  Joshua Hoblitt
    44#
    5 # $Id: 13_client_cull.t,v 1.3 2005-01-03 23:55:29 jhoblitt Exp $
     5# $Id: 13_client_cull.t,v 1.4 2005-06-30 02:35:06 jhoblitt Exp $
    66
    77use strict;
    … …  
    1414use lib qw( ./t ./lib );
    1515
    16 use PS::IPP::IData::Client;
    17 use PS::IPP::IData::Util qw( :standard );
    18 use Test::IData;
     16use Nebulous::Client;
     17use Nebulous::Util qw( :standard );
     18use Test::Nebulous;
    1919
    2020my $hostport = Apache::Test->config->{ 'hostport' };
    2121
    22 Test::IData->setup;
     22Test::Nebulous->setup;
    2323
    2424{
    2525    # key
    26     my $idata = PS::IPP::IData::Client->new(
    27         proxy => "http://$hostport/idata",
     26    my $neb = Nebulous::Client->new(
     27        proxy => "http://$hostport/nebulous",
    2828    );
    29     $idata->create( "foo" );
    30     $idata->replicate( "foo" );
     29    $neb->create( "foo" );
     30    $neb->replicate( "foo" );
    3131
    32     my $uri = $idata->cull( "foo" );
     32    my $uri = $neb->cull( "foo" );
    3333
    3434    ok( $uri, "good cull" );
    … …  
    3636}
    3737
    38 Test::IData->setup;
     38Test::Nebulous->setup;
    3939
    4040SKIP: {
    … …  
    4242
    4343    # key, $volume
    44     my $idata = PS::IPP::IData::Client->new(
    45         proxy => "http://$hostport/idata",
     44    my $neb = Nebulous::Client->new(
     45        proxy => "http://$hostport/nebulous",
    4646    );
    47     $idata->create( "foo" );
    48     $idata->replicate( "foo", "node01" );
     47    $neb->create( "foo" );
     48    $neb->replicate( "foo", "node01" );
    4949
    50     my $uri = $idata->cull( "foo", "node01" );
     50    my $uri = $neb->cull( "foo", "node01" );
    5151
    5252    ok( $uri, "good cull" );
    … …  
    5454}
    5555
    56 Test::IData->setup;
     56Test::Nebulous->setup;
    5757
    5858{
    5959    # key
    60     my $idata = PS::IPP::IData::Client->new(
    61         proxy => "http://$hostport/idata",
     60    my $neb = Nebulous::Client->new(
     61        proxy => "http://$hostport/nebulous",
    6262    );
    63     $idata->create( "foo" );
     63    $neb->create( "foo" );
    6464
    65     $idata->replicate( "foo", "node01" );
    66     $idata->replicate( "foo", "node02" );
     65    $neb->replicate( "foo", "node01" );
     66    $neb->replicate( "foo", "node02" );
    6767
    68     my $uri1 = $idata->cull( "foo" );
    69     my $uri2 = $idata->cull( "foo" );
     68    my $uri1 = $neb->cull( "foo" );
     69    my $uri2 = $neb->cull( "foo" );
    7070
    7171    ok( $uri1, "good cull" );
    … …  
    7575}
    7676
    77 Test::IData->setup;
     77Test::Nebulous->setup;
    7878
    7979SKIP: {
    … …  
    8181
    8282    # key, $volume
    83     my $idata = PS::IPP::IData::Client->new(
    84         proxy => "http://$hostport/idata",
     83    my $neb = Nebulous::Client->new(
     84        proxy => "http://$hostport/nebulous",
    8585    );
    86     $idata->create( "foo" );
     86    $neb->create( "foo" );
    8787
    88     $idata->replicate( "foo", "node01" );
    89     $idata->replicate( "foo", "node02" );
     88    $neb->replicate( "foo", "node01" );
     89    $neb->replicate( "foo", "node02" );
    9090
    91     my $uri1 = $idata->cull( "foo", "node01" );
    92     my $uri2 = $idata->cull( "foo", "node02" );
     91    my $uri1 = $neb->cull( "foo", "node01" );
     92    my $uri2 = $neb->cull( "foo", "node02" );
    9393
    9494    ok( $uri1, "good cull" );
    … …  
    9898}
    9999
    100 Test::IData->setup;
     100Test::Nebulous->setup;
    101101
    102102{
    103     my $idata = PS::IPP::IData::Client->new(
    104         proxy => "http://$hostport/idata",
     103    my $neb = Nebulous::Client->new(
     104        proxy => "http://$hostport/nebulous",
    105105    );
    106     my $uri = $idata->cull( "foo" );
     106    my $uri = $neb->cull( "foo" );
    107107
    108108    is( $uri, undef, "storage object does not exist" );
    109109}
    110110
    111 Test::IData->setup;
     111Test::Nebulous->setup;
    112112
    113113eval {
    114     my $idata = PS::IPP::IData::Client->new(
    115         proxy => "http://$hostport/idata",
     114    my $neb = Nebulous::Client->new(
     115        proxy => "http://$hostport/nebulous",
    116116    );
    117     $idata->cull();
     117    $neb->cull();
    118118};
    119119like( $@, qr/1 was expected/, "no params" );
    120120
    121 Test::IData->setup;
     121Test::Nebulous->setup;
    122122
    123123eval {
    124     my $idata = PS::IPP::IData::Client->new(
    125         proxy => "http://$hostport/idata",
     124    my $neb = Nebulous::Client->new(
     125        proxy => "http://$hostport/nebulous",
    126126    );
    127     $idata->cull( 1, 2 );
     127    $neb->cull( 1, 2 );
    128128};
    129129like( $@, qr/1 was expected/, "too many params" );
    130130
    131 Test::IData->cleanup;
     131Test::Nebulous->cleanup;

  • trunk/Nebulous-Server/t/14_client_lock.t

    r2872 r4440  
    33# Copryight (C) 2004-2005  Joshua Hoblitt
    44#
    5 # $Id: 14_client_lock.t,v 1.3 2005-01-03 23:55:29 jhoblitt Exp $
     5# $Id: 14_client_lock.t,v 1.4 2005-06-30 02:35:06 jhoblitt Exp $
    66
    77use strict;
    … …  
    1414use lib qw( ./t ./lib );
    1515
    16 use PS::IPP::IData::Client;
    17 use PS::IPP::IData::Util qw( :standard );
    18 use Test::IData;
     16use Nebulous::Client;
     17use Nebulous::Util qw( :standard );
     18use Test::Nebulous;
    1919
    2020my $hostport = Apache::Test->config->{ 'hostport' };
    2121
    22 Test::IData->setup;
     22Test::Nebulous->setup;
    2323
    2424{
    2525    # key, type
    26     my $idata = PS::IPP::IData::Client->new(
    27         proxy => "http://$hostport/idata",
    28     );
    29     $idata->create( "foo" );
    30 
    31     ok( $idata->lock( "foo", "read" ), "read lock" );
    32 }
    33 
    34 Test::IData->setup;
    35 
    36 {
    37     # key, type, timeout
    38     my $idata = PS::IPP::IData::Client->new(
    39         proxy => "http://$hostport/idata",
    40     );
    41     $idata->create( "foo" );
    42 
    43     ok( $idata->lock( "foo", "read", 10 ), "read lock" );
    44 }
    45 
    46 Test::IData->setup;
    47 
    48 {
    49     my $idata = PS::IPP::IData::Client->new(
    50         proxy => "http://$hostport/idata",
    51     );
    52     $idata->create( "foo" );
    53 
    54     ok( $idata->lock( "foo", "read" ), "read lock" );
    55     ok( $idata->lock( "foo", "read" ), "read lock" );
    56 }
    57 
    58 Test::IData->setup;
     26    my $neb = Nebulous::Client->new(
     27        proxy => "http://$hostport/nebulous",
     28    );
     29    $neb->create( "foo" );
     30
     31    ok( $neb->lock( "foo", "read" ), "read lock" );
     32}
     33
     34Test::Nebulous->setup;
     35
     36{
     37    # key, type, timeout
     38    my $neb = Nebulous::Client->new(
     39        proxy => "http://$hostport/nebulous",
     40    );
     41    $neb->create( "foo" );
     42
     43    ok( $neb->lock( "foo", "read", 10 ), "read lock" );
     44}
     45
     46Test::Nebulous->setup;
     47
     48{
     49    my $neb = Nebulous::Client->new(
     50        proxy => "http://$hostport/nebulous",
     51    );
     52    $neb->create( "foo" );
     53
     54    ok( $neb->lock( "foo", "read" ), "read lock" );
     55    ok( $neb->lock( "foo", "read" ), "read lock" );
     56}
     57
     58Test::Nebulous->setup;
    5959
    6060{
    6161    # key, type
    62     my $idata = PS::IPP::IData::Client->new(
    63         proxy => "http://$hostport/idata",
    64     );
    65     $idata->create( "foo" );
    66 
    67     ok( $idata->lock( "foo", "write" ), "write lock" );
    68 }
    69 
    70 Test::IData->setup;
    71 
    72 {
    73     # key, type, timeout
    74     my $idata = PS::IPP::IData::Client->new(
    75         proxy => "http://$hostport/idata",
    76     );
    77     $idata->create( "foo" );
    78 
    79     ok( $idata->lock( "foo", "write", 10 ), "write lock" );
    80 }
    81 
    82 Test::IData->setup;
    83 
    84 {
    85     my $idata = PS::IPP::IData::Client->new(
    86         proxy => "http://$hostport/idata",
    87     );
    88 
    89     is( $idata->lock( "foo", "read" ), undef, "storage object does not exist" );
    90 }
    91 
    92 Test::IData->setup;
    93 
    94 {
    95     my $idata = PS::IPP::IData::Client->new(
    96         proxy => "http://$hostport/idata",
    97     );
    98 
    99     is( $idata->lock( "foo", "write" ), undef, "storage object does not exist" );
    100 }
    101 
    102 Test::IData->setup;
     62    my $neb = Nebulous::Client->new(
     63        proxy => "http://$hostport/nebulous",
     64    );
     65    $neb->create( "foo" );
     66
     67    ok( $neb->lock( "foo", "write" ), "write lock" );
     68}
     69
     70Test::Nebulous->setup;
     71
     72{
     73    # key, type, timeout
     74    my $neb = Nebulous::Client->new(
     75        proxy => "http://$hostport/nebulous",
     76    );
     77    $neb->create( "foo" );
     78
     79    ok( $neb->lock( "foo", "write", 10 ), "write lock" );
     80}
     81
     82Test::Nebulous->setup;
     83
     84{
     85    my $neb = Nebulous::Client->new(
     86        proxy => "http://$hostport/nebulous",
     87    );
     88
     89    is( $neb->lock( "foo", "read" ), undef, "storage object does not exist" );
     90}
     91
     92Test::Nebulous->setup;
     93
     94{
     95    my $neb = Nebulous::Client->new(
     96        proxy => "http://$hostport/nebulous",
     97    );
     98
     99    is( $neb->lock( "foo", "write" ), undef, "storage object does not exist" );
     100}
     101
     102Test::Nebulous->setup;
    103103
    104104diag "testing a spinlock, this will be a litle slow...";
    … …  
    109109
    110110    # key, type, timeout
    111     my $idata = PS::IPP::IData::Client->new(
    112         proxy => "http://$hostport/idata",
    113     );
    114     $idata->create( "foo" );
    115 
    116     $idata->lock( "foo", "read" );
    117     $idata->lock( "foo", "write" );
     111    my $neb = Nebulous::Client->new(
     112        proxy => "http://$hostport/nebulous",
     113    );
     114    $neb->create( "foo" );
     115
     116    $neb->lock( "foo", "read" );
     117    $neb->lock( "foo", "write" );
    118118
    119119    alarm 0;
    … …  
    121121like( $@, qr/timeout/, "default spinlock" );
    122122
    123 Test::IData->setup;
     123Test::Nebulous->setup;
    124124
    125125diag "testing a spinlock, this will be a litle slow...";
    … …  
    130130
    131131    # key, type, timeout
    132     my $idata = PS::IPP::IData::Client->new(
    133         proxy => "http://$hostport/idata",
    134     );
    135     $idata->create( "foo" );
    136 
    137     $idata->lock( "foo", "read" );
    138     unless ( $idata->lock( "foo", "write" ) ) {
     132    my $neb = Nebulous::Client->new(
     133        proxy => "http://$hostport/nebulous",
     134    );
     135    $neb->create( "foo" );
     136
     137    $neb->lock( "foo", "read" );
     138    unless ( $neb->lock( "foo", "write" ) ) {
    139139        alarm 0;
    140140        die "gaveup";
    … …  
    145145like( $@, qr/gaveup/, "default spinlock" );
    146146
    147 Test::IData->setup;
     147Test::Nebulous->setup;
    148148
    149149diag "testing a spinlock, this will be a litle slow...";
    … …  
    154154
    155155    # key, type, timeout
    156     my $idata = PS::IPP::IData::Client->new(
    157         proxy => "http://$hostport/idata",
    158     );
    159     $idata->create( "foo" );
    160 
    161     $idata->lock( "foo", "read" );
    162     $idata->lock( "foo", "write", 5 );
     156    my $neb = Nebulous::Client->new(
     157        proxy => "http://$hostport/nebulous",
     158    );
     159    $neb->create( "foo" );
     160
     161    $neb->lock( "foo", "read" );
     162    $neb->lock( "foo", "write", 5 );
    163163
    164164    alarm 0;
    … …  
    166166like( $@, qr/timeout/, "specified spinlock" );
    167167
    168 Test::IData->setup;
     168Test::Nebulous->setup;
    169169
    170170diag "testing a spinlock, this will be a litle slow...";
    … …  
    175175
    176176    # key, type, timeout
    177     my $idata = PS::IPP::IData::Client->new(
    178         proxy => "http://$hostport/idata",
    179     );
    180     $idata->create( "foo" );
    181 
    182     $idata->lock( "foo", "read" );
    183     unless ( $idata->lock( "foo", "write", 5 ) ) {
     177    my $neb = Nebulous::Client->new(
     178        proxy => "http://$hostport/nebulous",
     179    );
     180    $neb->create( "foo" );
     181
     182    $neb->lock( "foo", "read" );
     183    unless ( $neb->lock( "foo", "write", 5 ) ) {
    184184        alarm 0;
    185185        die "gaveup";
    … …  
    191191like( $@, qr/gaveup/, "specified spinlock" );
    192192
    193 Test::IData->setup;
    194 
    195 {
    196     my $idata = PS::IPP::IData::Client->new(
    197         proxy => "http://$hostport/idata",
    198     );
    199     $idata->create( "foo" );
    200 
    201     $idata->lock( "foo", "write" );
    202     is( $idata->lock( "foo", "write", 1 ), undef, "can not write lock twice" );
    203 }
    204 
    205 Test::IData->setup;
    206 
    207 {
    208     my $idata = PS::IPP::IData::Client->new(
    209         proxy => "http://$hostport/idata",
    210     );
    211     $idata->create( "foo" );
    212 
    213     $idata->lock( "foo", "read" );
    214     is( $idata->lock( "foo", "write", 1 ), undef, "can not write lock after read lock" );
    215 }
    216 
    217 Test::IData->setup;
    218 
    219 {
    220     my $idata = PS::IPP::IData::Client->new(
    221         proxy => "http://$hostport/idata",
    222     );
    223     $idata->create( "foo" );
    224 
    225     $idata->lock( "foo", "write" );
    226     is( $idata->lock( "foo", "read", 1 ), undef, "can not read lock after write lock" );
    227 }
    228 
    229 Test::IData->setup;
    230 
    231 eval {
    232     my $idata = PS::IPP::IData::Client->new(
    233         proxy => "http://$hostport/idata",
    234     );
    235 
    236     $idata->lock();
     193Test::Nebulous->setup;
     194
     195{
     196    my $neb = Nebulous::Client->new(
     197        proxy => "http://$hostport/nebulous",
     198    );
     199    $neb->create( "foo" );
     200
     201    $neb->lock( "foo", "write" );
     202    is( $neb->lock( "foo", "write", 1 ), undef, "can not write lock twice" );
     203}
     204
     205Test::Nebulous->setup;
     206
     207{
     208    my $neb = Nebulous::Client->new(
     209        proxy => "http://$hostport/nebulous",
     210    );
     211    $neb->create( "foo" );
     212
     213    $neb->lock( "foo", "read" );
     214    is( $neb->lock( "foo", "write", 1 ), undef, "can not write lock after read lock" );
     215}
     216
     217Test::Nebulous->setup;
     218
     219{
     220    my $neb = Nebulous::Client->new(
     221        proxy => "http://$hostport/nebulous",
     222    );
     223    $neb->create( "foo" );
     224
     225    $neb->lock( "foo", "write" );
     226    is( $neb->lock( "foo", "read", 1 ), undef, "can not read lock after write lock" );
     227}
     228
     229Test::Nebulous->setup;
     230
     231eval {
     232    my $neb = Nebulous::Client->new(
     233        proxy => "http://$hostport/nebulous",
     234    );
     235
     236    $neb->lock();
    237237};
    238238like( $@, qr/2 - 3 were expected/, "no params" );
    239239
    240 Test::IData->setup;
    241 
    242 eval {
    243     my $idata = PS::IPP::IData::Client->new(
    244         proxy => "http://$hostport/idata",
    245     );
    246 
    247     $idata->lock( "foo" );
     240Test::Nebulous->setup;
     241
     242eval {
     243    my $neb = Nebulous::Client->new(
     244        proxy => "http://$hostport/nebulous",
     245    );
     246
     247    $neb->lock( "foo" );
    248248};
    249249like( $@, qr/2 - 3 were expected/, "not enough params" );
    250250
    251 Test::IData->setup;
    252 
    253 eval {
    254     my $idata = PS::IPP::IData::Client->new(
    255         proxy => "http://$hostport/idata",
    256     );
    257 
    258     $idata->lock( "foo", "both" );
     251Test::Nebulous->setup;
     252
     253eval {
     254    my $neb = Nebulous::Client->new(
     255        proxy => "http://$hostport/nebulous",
     256    );
     257
     258    $neb->lock( "foo", "both" );
    259259};
    260260like( $@, qr/is read or write/, "not read or write" );
    261261
    262 Test::IData->setup;
    263 
    264 eval {
    265     my $idata = PS::IPP::IData::Client->new(
    266         proxy => "http://$hostport/idata",
    267     );
    268 
    269     $idata->lock( "foo", 'read', 3, "bar" );
     262Test::Nebulous->setup;
     263
     264eval {
     265    my $neb = Nebulous::Client->new(
     266        proxy => "http://$hostport/nebulous",
     267    );
     268
     269    $neb->lock( "foo", 'read', 3, "bar" );
    270270};
    271271like( $@, qr/2 - 3 were expected/, "too many params" );
    272272
    273 Test::IData->cleanup;
     273Test::Nebulous->cleanup;

  • trunk/Nebulous-Server/t/15_client_unlock.t

    r2872 r4440  
    33# Copryight (C) 2004-2005  Joshua Hoblitt
    44#
    5 # $Id: 15_client_unlock.t,v 1.3 2005-01-03 23:55:29 jhoblitt Exp $
     5# $Id: 15_client_unlock.t,v 1.4 2005-06-30 02:35:06 jhoblitt Exp $
    66
    77use strict;
    … …  
    1414use lib qw( ./t ./lib );
    1515
    16 use PS::IPP::IData::Client;
    17 use PS::IPP::IData::Util qw( :standard );
    18 use Test::IData;
     16use Nebulous::Client;
     17use Nebulous::Util qw( :standard );
     18use Test::Nebulous;
    1919
    2020my $hostport = Apache::Test->config->{ 'hostport' };
    2121
    22 Test::IData->setup;
     22Test::Nebulous->setup;
    2323
    2424{
    25     my $idata = PS::IPP::IData::Client->new(
    26         proxy => "http://$hostport/idata",
     25    my $neb = Nebulous::Client->new(
     26        proxy => "http://$hostport/nebulous",
    2727    );
    28     $idata->create( "foo" );
    29     $idata->lock( "foo", "read" );
     28    $neb->create( "foo" );
     29    $neb->lock( "foo", "read" );
    3030
    31     ok( $idata->unlock( "foo", "read" ), "read unlock" );
     31    ok( $neb->unlock( "foo", "read" ), "read unlock" );
    3232}
    3333
    34 Test::IData->setup;
     34Test::Nebulous->setup;
    3535
    3636{
    37     my $idata = PS::IPP::IData::Client->new(
    38         proxy => "http://$hostport/idata",
     37    my $neb = Nebulous::Client->new(
     38        proxy => "http://$hostport/nebulous",
    3939    );
    40     $idata->create( "foo" );
    41     $idata->lock( "foo", "read" );
    42     $idata->lock( "foo", "read" );
     40    $neb->create( "foo" );
     41    $neb->lock( "foo", "read" );
     42    $neb->lock( "foo", "read" );
    4343
    44     ok( $idata->unlock( "foo", "read" ), "read unlock" );
    45     ok( $idata->unlock( "foo", "read" ), "read unlock" );
     44    ok( $neb->unlock( "foo", "read" ), "read unlock" );
     45    ok( $neb->unlock( "foo", "read" ), "read unlock" );
    4646}
    4747
    48 Test::IData->setup;
     48Test::Nebulous->setup;
    4949
    5050{
    51     my $idata = PS::IPP::IData::Client->new(
    52         proxy => "http://$hostport/idata",
     51    my $neb = Nebulous::Client->new(
     52        proxy => "http://$hostport/nebulous",
    5353    );
    54     $idata->create( "foo" );
    55     $idata->lock( "foo", "write" );
     54    $neb->create( "foo" );
     55    $neb->lock( "foo", "write" );
    5656
    57     ok( $idata->unlock( "foo", "write" ), "write unlock" );
     57    ok( $neb->unlock( "foo", "write" ), "write unlock" );
    5858}
    5959
    60 Test::IData->setup;
     60Test::Nebulous->setup;
    6161
    6262{
    63     my $idata = PS::IPP::IData::Client->new(
    64         proxy => "http://$hostport/idata",
     63    my $neb = Nebulous::Client->new(
     64        proxy => "http://$hostport/nebulous",
    6565    );
    6666
    67     is( $idata->unlock( "foo", "read" ), undef, "storage object does not exist" );
     67    is( $neb->unlock( "foo", "read" ), undef, "storage object does not exist" );
    6868}
    6969
    70 Test::IData->setup;
     70Test::Nebulous->setup;
    7171
    7272{
    73     my $idata = PS::IPP::IData::Client->new(
    74         proxy => "http://$hostport/idata",
     73    my $neb = Nebulous::Client->new(
     74        proxy => "http://$hostport/nebulous",
    7575    );
    7676
    77     is( $idata->unlock( "foo", "write" ), undef, "storage object does not exist" );
     77    is( $neb->unlock( "foo", "write" ), undef, "storage object does not exist" );
    7878}
    7979
    80 Test::IData->setup;
     80Test::Nebulous->setup;
    8181
    8282{
    83     my $idata = PS::IPP::IData::Client->new(
    84         proxy => "http://$hostport/idata",
     83    my $neb = Nebulous::Client->new(
     84        proxy => "http://$hostport/nebulous",
    8585    );
    86     $idata->create( "foo" );
     86    $neb->create( "foo" );
    8787
    88     is( $idata->unlock( "foo", "read" ), undef, "no lock set" );
     88    is( $neb->unlock( "foo", "read" ), undef, "no lock set" );
    8989}
    9090
    91 Test::IData->setup;
     91Test::Nebulous->setup;
    9292
    9393{
    94     my $idata = PS::IPP::IData::Client->new(
    95         proxy => "http://$hostport/idata",
     94    my $neb = Nebulous::Client->new(
     95        proxy => "http://$hostport/nebulous",
    9696    );
    97     $idata->create( "foo" );
     97    $neb->create( "foo" );
    9898
    99     is( $idata->unlock( "foo", "write" ), undef, "no lock set" );
     99    is( $neb->unlock( "foo", "write" ), undef, "no lock set" );
    100100}
    101101
    102 Test::IData->setup;
     102Test::Nebulous->setup;
    103103
    104104{
    105     my $idata = PS::IPP::IData::Client->new(
    106         proxy => "http://$hostport/idata",
     105    my $neb = Nebulous::Client->new(
     106        proxy => "http://$hostport/nebulous",
    107107    );
    108     $idata->create( "foo" );
    109     $idata->lock( "foo", "write" );
     108    $neb->create( "foo" );
     109    $neb->lock( "foo", "write" );
    110110
    111     is( $idata->unlock( "foo", "read" ), undef, "read unlock under write lock" );
     111    is( $neb->unlock( "foo", "read" ), undef, "read unlock under write lock" );
    112112}
    113113
    114 Test::IData->setup;
     114Test::Nebulous->setup;
    115115
    116116{
    117     my $idata = PS::IPP::IData::Client->new(
    118         proxy => "http://$hostport/idata",
     117    my $neb = Nebulous::Client->new(
     118        proxy => "http://$hostport/nebulous",
    119119    );
    120     $idata->create( "foo" );
    121     $idata->lock( "foo", "read" );
     120    $neb->create( "foo" );
     121    $neb->lock( "foo", "read" );
    122122
    123     is( $idata->unlock( "foo", "write" ), undef, "write unlock under read lock" );
     123    is( $neb->unlock( "foo", "write" ), undef, "write unlock under read lock" );
    124124}
    125125
    126 Test::IData->setup;
     126Test::Nebulous->setup;
    127127
    128128eval {
    129     my $idata = PS::IPP::IData::Client->new(
    130         proxy => "http://$hostport/idata",
     129    my $neb = Nebulous::Client->new(
     130        proxy => "http://$hostport/nebulous",
    131131    );
    132132
    133     $idata->unlock();
     133    $neb->unlock();
    134134};
    135135like( $@, qr/2 were expected/, "no params" );
    136136
    137 Test::IData->setup;
     137Test::Nebulous->setup;
    138138
    139139eval {
    140     my $idata = PS::IPP::IData::Client->new(
    141         proxy => "http://$hostport/idata",
     140    my $neb = Nebulous::Client->new(
     141        proxy => "http://$hostport/nebulous",
    142142    );
    143143
    144     $idata->unlock( "foo" );
     144    $neb->unlock( "foo" );
    145145};
    146146like( $@, qr/2 were expected/, "not enough params" );
    147147
    148 Test::IData->setup;
     148Test::Nebulous->setup;
    149149
    150150eval {
    151     my $idata = PS::IPP::IData::Client->new(
    152         proxy => "http://$hostport/idata",
     151    my $neb = Nebulous::Client->new(
     152        proxy => "http://$hostport/nebulous",
    153153    );
    154154
    155     $idata->unlock( "foo", "both" );
     155    $neb->unlock( "foo", "both" );
    156156};
    157157like( $@, qr/is read or write/, "not read or write" );
    158158
    159 Test::IData->setup;
     159Test::Nebulous->setup;
    160160
    161161eval {
    162     my $idata = PS::IPP::IData::Client->new(
    163         proxy => "http://$hostport/idata",
     162    my $neb = Nebulous::Client->new(
     163        proxy => "http://$hostport/nebulous",
    164164    );
    165165
    166     $idata->unlock( "foo", 'read', 3 );
     166    $neb->unlock( "foo", 'read', 3 );
    167167};
    168168like( $@, qr/2 were expected/, "too many params" );
    169169
    170 Test::IData->cleanup;
     170Test::Nebulous->cleanup;

  • trunk/Nebulous-Server/t/16_client_find_instances.t

    r2872 r4440  
    33# Copryight (C) 2004-2005  Joshua Hoblitt
    44#
    5 # $Id: 16_client_find_instances.t,v 1.5 2005-01-03 23:55:29 jhoblitt Exp $
     5# $Id: 16_client_find_instances.t,v 1.6 2005-06-30 02:35:06 jhoblitt Exp $
    66
    77use strict;
    … …  
    1414use lib qw( ./t ./lib );
    1515
    16 use PS::IPP::IData::Client;
    17 use PS::IPP::IData::Util qw( :standard );
    18 use Test::IData;
     16use Nebulous::Client;
     17use Nebulous::Util qw( :standard );
     18use Test::Nebulous;
    1919
    2020my $hostport = Apache::Test->config->{ 'hostport' };
    2121
    22 Test::IData->setup;
     22Test::Nebulous->setup;
    2323
    2424{
    2525    # key
    26     my $idata = PS::IPP::IData::Client->new(
    27         proxy => "http://$hostport/idata",
     26    my $neb = Nebulous::Client->new(
     27        proxy => "http://$hostport/nebulous",
    2828    );
    29     $idata->create( "foo" );
     29    $neb->create( "foo" );
    3030
    31     my $locations = $idata->find_instances( "foo" );
     31    my $locations = $neb->find_instances( "foo" );
    3232
    3333    is( scalar @$locations, 1, "found 1" );
    … …  
    3636}
    3737
    38 Test::IData->setup;
     38Test::Nebulous->setup;
    3939
    4040{
    4141    # key
    42     my $idata = PS::IPP::IData::Client->new(
    43         proxy => "http://$hostport/idata",
     42    my $neb = Nebulous::Client->new(
     43        proxy => "http://$hostport/nebulous",
    4444    );
    45     $idata->create( "foo" );
    46     $idata->replicate( "foo" );
     45    $neb->create( "foo" );
     46    $neb->replicate( "foo" );
    4747
    48     my $locations = $idata->find_instances( "foo" );
     48    my $locations = $neb->find_instances( "foo" );
    4949
    5050    is( scalar @$locations, 2, "found 2" );
    … …  
    5555}
    5656
    57 Test::IData->setup;
     57Test::Nebulous->setup;
    5858
    5959{
    6060    # key, volume
    61     my $idata = PS::IPP::IData::Client->new(
    62         proxy => "http://$hostport/idata",
     61    my $neb = Nebulous::Client->new(
     62        proxy => "http://$hostport/nebulous",
    6363    );
    64     $idata->create( "foo" );
     64    $neb->create( "foo" );
    6565
    66     my $locations = $idata->find_instances( "foo", "node01" );
     66    my $locations = $neb->find_instances( "foo", "node01" );
    6767
    6868    is( scalar @$locations, 1, "found 1" );
    … …  
    7171}
    7272
    73 Test::IData->setup;
     73Test::Nebulous->setup;
    7474
    7575{
    7676    # key
    77     my $idata = PS::IPP::IData::Client->new(
    78         proxy => "http://$hostport/idata",
     77    my $neb = Nebulous::Client->new(
     78        proxy => "http://$hostport/nebulous",
    7979    );
    80     $idata->create( "foo" );
    81     $idata->replicate( "foo" );
     80    $neb->create( "foo" );
     81    $neb->replicate( "foo" );
    8282
    83     my $locations = $idata->find_instances( "foo", "node01" );
     83    my $locations = $neb->find_instances( "foo", "node01" );
    8484
    8585    is( scalar @$locations, 2, "found 2" );
    … …  
    9090}
    9191
    92 Test::IData->setup;
     92Test::Nebulous->setup;
    9393
    9494{
    95     my $idata = PS::IPP::IData::Client->new(
    96         proxy => "http://$hostport/idata",
     95    my $neb = Nebulous::Client->new(
     96        proxy => "http://$hostport/nebulous",
    9797    );
    9898
    99     is( $idata->find_instances( "foo" ), undef, "storage object does not exist" );
     99    is( $neb->find_instances( "foo" ), undef, "storage object does not exist" );
    100100}
    101101
    102 Test::IData->setup;
     102Test::Nebulous->setup;
    103103
    104104eval {
    105     my $idata = PS::IPP::IData::Client->new(
    106         proxy => "http://$hostport/idata",
     105    my $neb = Nebulous::Client->new(
     106        proxy => "http://$hostport/nebulous",
    107107    );
    108108
    109     $idata->find_instances();
     109    $neb->find_instances();
    110110};
    111111like( $@, qr/1 - 2 were expected/, "no params" );
    112112
    113 Test::IData->setup;
     113Test::Nebulous->setup;
    114114
    115115eval {
    116     my $idata = PS::IPP::IData::Client->new(
    117         proxy => "http://$hostport/idata",
     116    my $neb = Nebulous::Client->new(
     117        proxy => "http://$hostport/nebulous",
    118118    );
    119119
    120     $idata->find_instances( "foo", 'read', 3 );
     120    $neb->find_instances( "foo", 'read', 3 );
    121121};
    122122like( $@, qr/1 - 2 were expected/, "too many params" );
    123123
    124 Test::IData->cleanup;
     124Test::Nebulous->cleanup;

  • trunk/Nebulous-Server/t/17_client_find.t

    r2872 r4440  
    33# Copryight (C) 2004-2005  Joshua Hoblitt
    44#
    5 # $Id: 17_client_find.t,v 1.3 2005-01-03 23:55:29 jhoblitt Exp $
     5# $Id: 17_client_find.t,v 1.4 2005-06-30 02:35:06 jhoblitt Exp $
    66
    77use strict;
    … …  
    1414use lib qw( ./t ./lib );
    1515
    16 use PS::IPP::IData::Client;
    17 use PS::IPP::IData::Util qw( :standard );
    18 use Test::IData;
     16use Nebulous::Client;
     17use Nebulous::Util qw( :standard );
     18use Test::Nebulous;
    1919
    2020my $hostport = Apache::Test->config->{ 'hostport' };
    2121
    22 Test::IData->setup;
     22Test::Nebulous->setup;
    2323
    2424{
    2525    # key
    26     my $idata = PS::IPP::IData::Client->new(
    27         proxy => "http://$hostport/idata",
     26    my $neb = Nebulous::Client->new(
     27        proxy => "http://$hostport/nebulous",
    2828    );
    29     my $uri = $idata->create( "foo" );
     29    my $uri = $neb->create( "foo" );
    3030
    31     my $path = $idata->find( "foo" );
     31    my $path = $neb->find( "foo" );
    3232
    3333    ok( -e $path, "file exists" );
    3434}
    3535
    36 Test::IData->setup;
     36Test::Nebulous->setup;
    3737
    3838{
    39     my $idata = PS::IPP::IData::Client->new(
    40         proxy => "http://$hostport/idata",
     39    my $neb = Nebulous::Client->new(
     40        proxy => "http://$hostport/nebulous",
    4141    );
    4242
    43     my $path = $idata->find( "foo" );
     43    my $path = $neb->find( "foo" );
    4444
    4545    ok( ! -e $path, "file doesn't exist" );
    4646}
    4747
    48 Test::IData->setup;
     48Test::Nebulous->setup;
    4949
    5050eval {
    51     my $idata = PS::IPP::IData::Client->new(
    52         proxy => "http://$hostport/idata",
     51    my $neb = Nebulous::Client->new(
     52        proxy => "http://$hostport/nebulous",
    5353    );
    5454
    55     $idata->find();
     55    $neb->find();
    5656};
    5757like( $@, qr/1 was expected/, "no params" );
    5858
    59 Test::IData->setup;
     59Test::Nebulous->setup;
    6060
    6161eval {
    62     my $idata = PS::IPP::IData::Client->new(
    63         proxy => "http://$hostport/idata",
     62    my $neb = Nebulous::Client->new(
     63        proxy => "http://$hostport/nebulous",
    6464    );
    6565
    66     $idata->find( "foo", "bar" );
     66    $neb->find( "foo", "bar" );
    6767};
    6868like( $@, qr/1 was expected/, "too many params" );
    6969
    70 Test::IData->cleanup;
     70Test::Nebulous->cleanup;

  • trunk/Nebulous-Server/t/18_client_open.t

    r2896 r4440  
    33# Copryight (C) 2004-2005  Joshua Hoblitt
    44#
    5 # $Id: 18_client_open.t,v 1.1 2005-01-05 01:41:05 jhoblitt Exp $
     5# $Id: 18_client_open.t,v 1.2 2005-06-30 02:35:06 jhoblitt Exp $
    66
    77use strict;
    … …  
    1414use lib qw( ./t ./lib );
    1515
    16 use PS::IPP::IData::Client;
    17 use PS::IPP::IData::Util qw( :standard );
    18 use Test::IData;
     16use Nebulous::Client;
     17use Nebulous::Util qw( :standard );
     18use Test::Nebulous;
    1919
    2020my $hostport = Apache::Test->config->{ 'hostport' };
    2121
    22 Test::IData->setup;
     22Test::Nebulous->setup;
    2323
    2424{
    2525    # key
    26     my $idata = PS::IPP::IData::Client->new(
    27         proxy => "http://$hostport/idata",
     26    my $neb = Nebulous::Client->new(
     27        proxy => "http://$hostport/nebulous",
    2828    );
    29     $idata->create( "foo" );
    30     my $fh = $idata->open( "foo", 'read' );
     29    $neb->create( "foo" );
     30    my $fh = $neb->open( "foo", 'read' );
    3131
    3232    is( ref $fh, 'GLOB', "good filehandle" );
    3333}
    3434
    35 Test::IData->setup;
     35Test::Nebulous->setup;
    3636
    3737{
    3838    # key
    39     my $idata = PS::IPP::IData::Client->new(
    40         proxy => "http://$hostport/idata",
     39    my $neb = Nebulous::Client->new(
     40        proxy => "http://$hostport/nebulous",
    4141    );
    42     $idata->create( "foo" );
    43     my $fh = $idata->open( "foo", 'write' );
     42    $neb->create( "foo" );
     43    my $fh = $neb->open( "foo", 'write' );
    4444
    4545    is( ref $fh, 'GLOB', "good filehandle" );
    4646}
    4747
    48 Test::IData->setup;
     48Test::Nebulous->setup;
    4949
    5050{
    51     my $idata = PS::IPP::IData::Client->new(
    52         proxy => "http://$hostport/idata",
     51    my $neb = Nebulous::Client->new(
     52        proxy => "http://$hostport/nebulous",
    5353    );
    5454
    55     is( ref $idata->open( "foo", 'write' ), 'GLOB', "create new object" );
     55    is( ref $neb->open( "foo", 'write' ), 'GLOB', "create new object" );
    5656}
    5757
    58 Test::IData->setup;
     58Test::Nebulous->setup;
    5959
    6060{
    61     my $idata = PS::IPP::IData::Client->new(
    62         proxy => "http://$hostport/idata",
     61    my $neb = Nebulous::Client->new(
     62        proxy => "http://$hostport/nebulous",
    6363    );
    6464
    65     is( $idata->open( "foo", 'read' ), undef, "can't create new object" );
     65    is( $neb->open( "foo", 'read' ), undef, "can't create new object" );
    6666}
    6767
    68 Test::IData->setup;
     68Test::Nebulous->setup;
    6969
    7070eval {
    71     my $idata = PS::IPP::IData::Client->new(
    72         proxy => "http://$hostport/idata",
     71    my $neb = Nebulous::Client->new(
     72        proxy => "http://$hostport/nebulous",
    7373    );
    74     $idata->open( "foo", 'bar' );
     74    $neb->open( "foo", 'bar' );
    7575};
    7676like( $@, qr/is read or write/, "2nd params not read or write" );
    7777
    78 Test::IData->setup;
     78Test::Nebulous->setup;
    7979
    8080eval {
    81     my $idata = PS::IPP::IData::Client->new(
    82         proxy => "http://$hostport/idata",
     81    my $neb = Nebulous::Client->new(
     82        proxy => "http://$hostport/nebulous",
    8383    );
    84     $idata->open();
     84    $neb->open();
    8585};
    8686like( $@, qr/2 were expected/, "no params" );
    8787
    88 Test::IData->setup;
     88Test::Nebulous->setup;
    8989
    9090eval {
    91     my $idata = PS::IPP::IData::Client->new(
    92         proxy => "http://$hostport/idata",
     91    my $neb = Nebulous::Client->new(
     92        proxy => "http://$hostport/nebulous",
    9393    );
    94     $idata->open( 1, 'read', 3 );
     94    $neb->open( 1, 'read', 3 );
    9595};
    9696like( $@, qr/2 were expected/, "too many params" );
    9797
    98 Test::IData->cleanup;
     98Test::Nebulous->cleanup;

  • trunk/Nebulous-Server/t/19_client_delete.t

    r2913 r4440  
    33# Copryight (C) 2004-2005  Joshua Hoblitt
    44#
    5 # $Id: 19_client_delete.t,v 1.2 2005-01-05 22:27:22 jhoblitt Exp $
     5# $Id: 19_client_delete.t,v 1.3 2005-06-30 02:35:06 jhoblitt Exp $
    66
    77use strict;
    … …  
    1414use lib qw( ./t ./lib );
    1515
    16 use PS::IPP::IData::Client;
    17 use PS::IPP::IData::Util qw( :standard );
    18 use Test::IData;
     16use Nebulous::Client;
     17use Nebulous::Util qw( :standard );
     18use Test::Nebulous;
    1919
    2020my $hostport = Apache::Test->config->{ 'hostport' };
    2121
    22 Test::IData->setup;
     22Test::Nebulous->setup;
    2323
    2424{
    25     my $idata = PS::IPP::IData::Client->new(
    26         proxy => "http://$hostport/idata",
     25    my $neb = Nebulous::Client->new(
     26        proxy => "http://$hostport/nebulous",
    2727    );
    28     $idata->create( "foo" );
     28    $neb->create( "foo" );
    2929
    30     ok( $idata->delete( "foo" ), "delete object" );
     30    ok( $neb->delete( "foo" ), "delete object" );
    3131
    32     my $locations = $idata->find_instances( "foo" );
     32    my $locations = $neb->find_instances( "foo" );
    3333
    3434    is( $locations, undef, "no instances" );
    3535}
    3636
    37 Test::IData->setup;
     37Test::Nebulous->setup;
    3838
    3939{
    40     my $idata = PS::IPP::IData::Client->new(
    41         proxy => "http://$hostport/idata",
     40    my $neb = Nebulous::Client->new(
     41        proxy => "http://$hostport/nebulous",
    4242    );
    43     $idata->create( "foo" );
    44     $idata->replicate( "foo" );
     43    $neb->create( "foo" );
     44    $neb->replicate( "foo" );
    4545
    46     ok( $idata->delete( "foo" ), "delete object" );
     46    ok( $neb->delete( "foo" ), "delete object" );
    4747
    48     my $locations = $idata->find_instances( "foo" );
     48    my $locations = $neb->find_instances( "foo" );
    4949
    5050    is( $locations, undef, "no instances" );
    5151}
    5252
    53 Test::IData->setup;
     53Test::Nebulous->setup;
    5454
    5555{
    56     my $idata = PS::IPP::IData::Client->new(
    57         proxy => "http://$hostport/idata",
     56    my $neb = Nebulous::Client->new(
     57        proxy => "http://$hostport/nebulous",
    5858    );
    5959
    60     is( $idata->delete( "foo" ), undef, "delete non-existant object" );
     60    is( $neb->delete( "foo" ), undef, "delete non-existant object" );
    6161}
    6262
    63 Test::IData->setup;
     63Test::Nebulous->setup;
    6464
    6565eval {
    66     my $idata = PS::IPP::IData::Client->new(
    67         proxy => "http://$hostport/idata",
     66    my $neb = Nebulous::Client->new(
     67        proxy => "http://$hostport/nebulous",
    6868    );
    69     $idata->delete();
     69    $neb->delete();
    7070};
    7171like( $@, qr/1 was expected/, "no params" );
    7272
    73 Test::IData->setup;
     73Test::Nebulous->setup;
    7474
    7575eval {
    76     my $idata = PS::IPP::IData::Client->new(
    77         proxy => "http://$hostport/idata",
     76    my $neb = Nebulous::Client->new(
     77        proxy => "http://$hostport/nebulous",
    7878    );
    79     $idata->delete( "foo", 2 );
     79    $neb->delete( "foo", 2 );
    8080};
    8181like( $@, qr/1 was expected/, "too many params" );
    8282
    83 Test::IData->cleanup;
     83Test::Nebulous->cleanup;

  • trunk/Nebulous-Server/t/20_client_copy.t

    r2878 r4440  
    33# Copryight (C) 2004-2005  Joshua Hoblitt
    44#
    5 # $Id: 20_client_copy.t,v 1.1 2005-01-04 02:13:21 jhoblitt Exp $
     5# $Id: 20_client_copy.t,v 1.2 2005-06-30 02:35:06 jhoblitt Exp $
    66
    77use strict;
    … …  
    1414use lib qw( ./t ./lib );
    1515
    16 use PS::IPP::IData::Client;
    17 use PS::IPP::IData::Util qw( :standard );
    18 use Test::IData;
     16use Nebulous::Client;
     17use Nebulous::Util qw( :standard );
     18use Test::Nebulous;
    1919
    2020my $hostport = Apache::Test->config->{ 'hostport' };
    2121
    22 Test::IData->setup;
     22Test::Nebulous->setup;
    2323
    2424{
    25     my $idata = PS::IPP::IData::Client->new(
    26         proxy => "http://$hostport/idata",
     25    my $neb = Nebulous::Client->new(
     26        proxy => "http://$hostport/nebulous",
    2727    );
    28     $idata->create( "foo" );
     28    $neb->create( "foo" );
    2929
    30     ok( $idata->copy( "foo", "foobar" ), "copied object" );
     30    ok( $neb->copy( "foo", "foobar" ), "copied object" );
    3131
    32     my $locations1 = $idata->find_instances( "foobar" );
    33     my $locations2 = $idata->find_instances( "foobar" );
     32    my $locations1 = $neb->find_instances( "foobar" );
     33    my $locations2 = $neb->find_instances( "foobar" );
    3434
    3535    is( scalar @$locations1, 1, "old object has an instances" );
    … …  
    3737}
    3838
    39 Test::IData->setup;
     39Test::Nebulous->setup;
    4040
    4141{
    42     my $idata = PS::IPP::IData::Client->new(
    43         proxy => "http://$hostport/idata",
     42    my $neb = Nebulous::Client->new(
     43        proxy => "http://$hostport/nebulous",
    4444    );
    4545
    46     ok( ! $idata->copy( "foo", "foobar" ), "copy non-existant object" );
     46    ok( ! $neb->copy( "foo", "foobar" ), "copy non-existant object" );
    4747
    48     my $locations = $idata->find_instances( "foobar" );
     48    my $locations = $neb->find_instances( "foobar" );
    4949
    5050    is( $locations, undef, "new object has no instances" );
    5151}
    5252
    53 Test::IData->setup;
     53Test::Nebulous->setup;
    5454
    5555eval {
    56     my $idata = PS::IPP::IData::Client->new(
    57         proxy => "http://$hostport/idata",
     56    my $neb = Nebulous::Client->new(
     57        proxy => "http://$hostport/nebulous",
    5858    );
    59     $idata->copy();
     59    $neb->copy();
    6060};
    6161like( $@, qr/2 were expected/, "no params" );
    6262
    63 Test::IData->setup;
     63Test::Nebulous->setup;
    6464
    6565eval {
    66     my $idata = PS::IPP::IData::Client->new(
    67         proxy => "http://$hostport/idata",
     66    my $neb = Nebulous::Client->new(
     67        proxy => "http://$hostport/nebulous",
    6868    );
    69     $idata->copy( "foo" );
     69    $neb->copy( "foo" );
    7070};
    7171like( $@, qr/2 were expected/, "not enough params" );
    7272
    73 Test::IData->setup;
     73Test::Nebulous->setup;
    7474
    7575eval {
    76     my $idata = PS::IPP::IData::Client->new(
    77         proxy => "http://$hostport/idata",
     76    my $neb = Nebulous::Client->new(
     77        proxy => "http://$hostport/nebulous",
    7878    );
    79     $idata->copy( "foo", "bar", "baz" );
     79    $neb->copy( "foo", "bar", "baz" );
    8080};
    8181like( $@, qr/2 were expected/, "too many params" );
    8282
    83 Test::IData->cleanup;
     83Test::Nebulous->cleanup;

  • trunk/Nebulous-Server/t/21_client_move.t

    r2881 r4440  
    33# Copryight (C) 2004-2005  Joshua Hoblitt
    44#
    5 # $Id: 21_client_move.t,v 1.1 2005-01-04 02:48:31 jhoblitt Exp $
     5# $Id: 21_client_move.t,v 1.2 2005-06-30 02:35:06 jhoblitt Exp $
    66
    77use strict;
    … …  
    1414use lib qw( ./t ./lib );
    1515
    16 use PS::IPP::IData::Client;
    17 use PS::IPP::IData::Util qw( :standard );
    18 use Test::IData;
     16use Nebulous::Client;
     17use Nebulous::Util qw( :standard );
     18use Test::Nebulous;
    1919
    2020my $hostport = Apache::Test->config->{ 'hostport' };
    2121
    22 Test::IData->setup;
     22Test::Nebulous->setup;
    2323
    2424{
    25     my $idata = PS::IPP::IData::Client->new(
    26         proxy => "http://$hostport/idata",
     25    my $neb = Nebulous::Client->new(
     26        proxy => "http://$hostport/nebulous",
    2727    );
    28     $idata->create( "foo" );
     28    $neb->create( "foo" );
    2929
    30     ok( $idata->move( "foo", "foobar" ), "move object" );
     30    ok( $neb->move( "foo", "foobar" ), "move object" );
    3131
    32     my $locations1 = $idata->find_instances( "foo" );
    33     my $locations2 = $idata->find_instances( "foobar" );
     32    my $locations1 = $neb->find_instances( "foo" );
     33    my $locations2 = $neb->find_instances( "foobar" );
    3434
    3535    is( $locations1, undef, "old object has no instances" );
    … …  
    3737}
    3838
    39 Test::IData->setup;
     39Test::Nebulous->setup;
    4040
    4141{
    42     my $idata = PS::IPP::IData::Client->new(
    43         proxy => "http://$hostport/idata",
     42    my $neb = Nebulous::Client->new(
     43        proxy => "http://$hostport/nebulous",
    4444    );
    4545
    46     ok( ! $idata->move( "foo", "foobar" ), "move non-existant object" );
     46    ok( ! $neb->move( "foo", "foobar" ), "move non-existant object" );
    4747
    48     my $locations = $idata->find_instances( "foobar" );
     48    my $locations = $neb->find_instances( "foobar" );
    4949
    5050    is( $locations, undef, "new object has no instances" );
    5151}
    5252
    53 Test::IData->setup;
     53Test::Nebulous->setup;
    5454
    5555eval {
    56     my $idata = PS::IPP::IData::Client->new(
    57         proxy => "http://$hostport/idata",
     56    my $neb = Nebulous::Client->new(
     57        proxy => "http://$hostport/nebulous",
    5858    );
    59     $idata->move();
     59    $neb->move();
    6060};
    6161like( $@, qr/2 were expected/, "no params" );
    6262
    63 Test::IData->setup;
     63Test::Nebulous->setup;
    6464
    6565eval {
    66     my $idata = PS::IPP::IData::Client->new(
    67         proxy => "http://$hostport/idata",
     66    my $neb = Nebulous::Client->new(
     67        proxy => "http://$hostport/nebulous",
    6868    );
    69     $idata->move( "foo" );
     69    $neb->move( "foo" );
    7070};
    7171like( $@, qr/2 were expected/, "not enough params" );
    7272
    73 Test::IData->setup;
     73Test::Nebulous->setup;
    7474
    7575eval {
    76     my $idata = PS::IPP::IData::Client->new(
    77         proxy => "http://$hostport/idata",
     76    my $neb = Nebulous::Client->new(
     77        proxy => "http://$hostport/nebulous",
    7878    );
    79     $idata->move( "foo", "bar", "baz" );
     79    $neb->move( "foo", "bar", "baz" );
    8080};
    8181like( $@, qr/2 were expected/, "too many params" );
    8282
    83 Test::IData->cleanup;
     83Test::Nebulous->cleanup;

  • trunk/Nebulous-Server/t/22_client_delete_instance.t

    r2882 r4440  
    33# Copryight (C) 2004-2005  Joshua Hoblitt
    44#
    5 # $Id: 22_client_delete_instance.t,v 1.1 2005-01-04 03:14:19 jhoblitt Exp $
     5# $Id: 22_client_delete_instance.t,v 1.2 2005-06-30 02:35:06 jhoblitt Exp $
    66
    77use strict;
    … …  
    1414use lib qw( ./t ./lib );
    1515
    16 use PS::IPP::IData::Client;
    17 use PS::IPP::IData::Util qw( :standard );
    18 use Test::IData;
     16use Nebulous::Client;
     17use Nebulous::Util qw( :standard );
     18use Test::Nebulous;
    1919
    2020my $hostport = Apache::Test->config->{ 'hostport' };
    2121
    22 Test::IData->setup;
     22Test::Nebulous->setup;
    2323
    2424{
    25     my $idata = PS::IPP::IData::Client->new(
    26         proxy => "http://$hostport/idata",
     25    my $neb = Nebulous::Client->new(
     26        proxy => "http://$hostport/nebulous",
    2727    );
    28     $idata->create( "foo" );
     28    $neb->create( "foo" );
    2929
    30     my $locations = $idata->find_instances( "foo" );
     30    my $locations = $neb->find_instances( "foo" );
    3131
    32     my $uri = $idata->delete_instance( @$locations[0] );
     32    my $uri = $neb->delete_instance( @$locations[0] );
    3333
    3434    is( $uri, @$locations[0], "delete instance" );
    … …  
    3737}
    3838
    39 Test::IData->setup;
     39Test::Nebulous->setup;
    4040
    4141{
    42     my $idata = PS::IPP::IData::Client->new(
    43         proxy => "http://$hostport/idata",
     42    my $neb = Nebulous::Client->new(
     43        proxy => "http://$hostport/nebulous",
    4444    );
    45     $idata->create( "foo" );
    46     $idata->replicate( "foo" );
     45    $neb->create( "foo" );
     46    $neb->replicate( "foo" );
    4747
    48     my $uri1 = $idata->find_instances( "foo" )->[0];
     48    my $uri1 = $neb->find_instances( "foo" )->[0];
    4949
    50     ok( $idata->delete_instance( $uri1 ), "delete instance" );
     50    ok( $neb->delete_instance( $uri1 ), "delete instance" );
    5151
    52     my $uri2 = $idata->find_instances( "foo" )->[0];
     52    my $uri2 = $neb->find_instances( "foo" )->[0];
    5353
    5454    isnt( $uri1, $uri2, "other instance remains" );
    5555
    56     ok( $idata->delete_instance( $uri2 ), "delete instance" );
     56    ok( $neb->delete_instance( $uri2 ), "delete instance" );
    5757
    58     my $locations = $idata->find_instances( "foo" );
     58    my $locations = $neb->find_instances( "foo" );
    5959
    6060    is( $locations, undef, "no remaning instances" );
    … …  
    6262
    6363{
    64     my $idata = PS::IPP::IData::Client->new(
    65         proxy => "http://$hostport/idata",
     64    my $neb = Nebulous::Client->new(
     65        proxy => "http://$hostport/nebulous",
    6666    );
    67     my $uri = $idata->delete_instance( "file:/foo" );
     67    my $uri = $neb->delete_instance( "file:/foo" );
    6868
    6969    is( $uri, undef, "uri does not exist" );
    7070}
    7171
    72 Test::IData->setup;
     72Test::Nebulous->setup;
    7373
    7474eval {
    75     my $idata = PS::IPP::IData::Client->new(
    76         proxy => "http://$hostport/idata",
     75    my $neb = Nebulous::Client->new(
     76        proxy => "http://$hostport/nebulous",
    7777    );
    78     $idata->delete_instance();
     78    $neb->delete_instance();
    7979};
    8080like( $@, qr/1 was expected/, "no params" );
    8181
    82 Test::IData->setup;
     82Test::Nebulous->setup;
    8383
    8484eval {
    85     my $idata = PS::IPP::IData::Client->new(
    86         proxy => "http://$hostport/idata",
     85    my $neb = Nebulous::Client->new(
     86        proxy => "http://$hostport/nebulous",
    8787    );
    88     $idata->delete_instance( "foo", 2 );
     88    $neb->delete_instance( "foo", 2 );
    8989};
    9090like( $@, qr/1 was expected/, "too many params" );
    9191
    92 Test::IData->cleanup;
     92Test::Nebulous->cleanup;

  • trunk/Nebulous-Server/t/23_client_stat.t

    r3016 r4440  
    33# Copryight (C) 2004-2005  Joshua Hoblitt
    44#
    5 # $Id: 23_client_stat.t,v 1.2 2005-01-15 04:02:12 jhoblitt Exp $
     5# $Id: 23_client_stat.t,v 1.3 2005-06-30 02:35:06 jhoblitt Exp $
    66
    77use strict;
    … …  
    1414use lib qw( ./t ./lib );
    1515
    16 use PS::IPP::IData::Client;
    17 use PS::IPP::IData::Util qw( :standard );
    18 use Test::IData;
     16use Nebulous::Client;
     17use Nebulous::Util qw( :standard );
     18use Test::Nebulous;
    1919
    2020my $hostport = Apache::Test->config->{ 'hostport' };
    2121
    22 Test::IData->setup;
     22Test::Nebulous->setup;
    2323
    2424{
    25     my $idata = PS::IPP::IData::Client->new(
    26         proxy => "http://$hostport/idata",
     25    my $neb = Nebulous::Client->new(
     26        proxy => "http://$hostport/nebulous",
    2727    );
    28     $idata->create( "foo" );
     28    $neb->create( "foo" );
    2929
    30     my $info = $idata->stat( "foo" );
     30    my $info = $neb->stat( "foo" );
    3131
    3232    is( scalar @$info, 8, "number of columns" );
    3333}
    3434
    35 Test::IData->setup;
     35Test::Nebulous->setup;
    3636
    3737{
    38     my $idata = PS::IPP::IData::Client->new(
    39         proxy => "http://$hostport/idata",
     38    my $neb = Nebulous::Client->new(
     39        proxy => "http://$hostport/nebulous",
    4040    );
    41     $idata->create( "foo", 9, "node01", "foobar" );
     41    $neb->create( "foo", 9, "node01", "foobar" );
    4242
    43     my $info = $idata->stat( "foo" );
     43    my $info = $neb->stat( "foo" );
    4444
    4545    is( scalar @$info, 8,                       "number of columns" );
    … …  
    5454}
    5555
    56 Test::IData->setup;
     56Test::Nebulous->setup;
    5757
    5858{
    59     my $idata = PS::IPP::IData::Client->new(
    60         proxy => "http://$hostport/idata",
     59    my $neb = Nebulous::Client->new(
     60        proxy => "http://$hostport/nebulous",
    6161    );
    62     my $info = $idata->stat( "foo" );
     62    my $info = $neb->stat( "foo" );
    6363
    6464    is( $info, undef, "object does not exist" );
    6565}
    6666
    67 Test::IData->setup;
     67Test::Nebulous->setup;
    6868
    6969eval {
    70     my $idata = PS::IPP::IData::Client->new(
    71         proxy => "http://$hostport/idata",
     70    my $neb = Nebulous::Client->new(
     71        proxy => "http://$hostport/nebulous",
    7272    );
    73     $idata->stat();
     73    $neb->stat();
    7474};
    7575like( $@, qr/1 was expected/, "no params" );
    7676
    77 Test::IData->setup;
     77Test::Nebulous->setup;
    7878
    7979eval {
    80     my $idata = PS::IPP::IData::Client->new(
    81         proxy => "http://$hostport/idata",
     80    my $neb = Nebulous::Client->new(
     81        proxy => "http://$hostport/nebulous",
    8282    );
    83     $idata->stat( "foo", 2 );
     83    $neb->stat( "foo", 2 );
    8484};
    8585like( $@, qr/1 was expected/, "too many params" );
    8686
    87 Test::IData->cleanup;
     87Test::Nebulous->cleanup;

  • trunk/Nebulous-Server/t/apache_03_server_create_object.x

    r2785 r4440  
    1111
    1212use Apache::TestUtil;
    13 use PS::IPP::IData::Util qw( :standard );
     13use Nebulous::Util qw( :standard );
    1414use SOAP::Lite;
    15 use Test::IData;
     15use Test::Nebulous;
    1616
    1717my $hostport = Apache::Test::config()->{ 'hostport' };
    18 my $idata = SOAP::Lite->new(
    19     proxy   => "http://$hostport/idata",
    20     uri     => "http://pan-starrs.ifa.hawaii.edu/PS/IPP/IData/Server",
     18my $neb = SOAP::Lite->new(
     19    proxy   => "http://$hostport/nebulous",
     20    uri     => "http://pan-starrs.ifa.hawaii.edu/PS/IPP/Nebulous/Server",
    2121);
    2222
    23 Test::IData->setup;
     23Test::Nebulous->setup;
    2424
    2525{
    2626    # key
    27     my $uri = $idata->create_object( "foo" )->result;
     27    my $uri = $neb->create_object( "foo" )->result;
    2828
    2929    ok( -e _get_file_path( $uri ), "file exists" );
    … …  
    3232}
    3333
    34 Test::IData->setup;
     34Test::Nebulous->setup;
    3535
    3636{
    3737    # key, class
    38     my $uri = $idata->create_object( "foo", 0 )->result;
    39     $idata->delete_instance( $uri );
     38    my $uri = $neb->create_object( "foo", 0 )->result;
     39    $neb->delete_instance( $uri );
    4040
    4141    ok( -e _get_file_path( $uri ), "file exists" );
    … …  
    4444}
    4545
    46 Test::IData->setup;
     46Test::Nebulous->setup;
    4747
    4848{
    4949    # key, class, volume
    50     my $uri = $idata->create_object( "foo", 0, "node01" )->result;
    51     $idata->delete_instance( $uri );
     50    my $uri = $neb->create_object( "foo", 0, "node01" )->result;
     51    $neb->delete_instance( $uri );
    5252
    5353    ok( -e _get_file_path( $uri ), "file exists" );
    … …  
    5656}
    5757
    58 Test::IData->setup;
     58Test::Nebulous->setup;
    5959
    6060{
    6161    # key, class, volume, comment
    62     my $uri = $idata->create_object( "foo", 0, "node01", "this is foo" )->result;
    63     $idata->delete_instance( $uri );
     62    my $uri = $neb->create_object( "foo", 0, "node01", "this is foo" )->result;
     63    $neb->delete_instance( $uri );
    6464
    6565    ok( -e _get_file_path( $uri ), "file exists" );
    … …  
    6868}
    6969
    70 Test::IData->setup;
     70Test::Nebulous->setup;
    7171
    7272{
    73     $idata->create_object( "foo" );
    74     my $response = $idata->create_object( "foo" );
     73    $neb->create_object( "foo" );
     74    my $response = $neb->create_object( "foo" );
    7575
    7676    like( $response->faultstring, qr/Duplicate entry/, "object already exists" );
    7777}
    7878
    79 Test::IData->setup;
     79Test::Nebulous->setup;
    8080
    8181{
    82     my $response = $idata->create_object();
     82    my $response = $neb->create_object();
    8383
    8484    like( $response->faultstring, qr/2 - 4 were expected/, "no params" );
    8585}
    8686
    87 Test::IData->setup;
     87Test::Nebulous->setup;
    8888
    8989{
    90     my $response = $idata->create_object( 1, 2, 3, 4, 5 );
     90    my $response = $neb->create_object( 1, 2, 3, 4, 5 );
    9191
    9292    like( $response->faultstring, qr/2 - 4 were expected/, "too many params" );
    9393}
    9494
    95 Test::IData->cleanup;
     95Test::Nebulous->cleanup;

  • trunk/Nebulous-Server/t/apache_04_server_replicate_object.x

    r2785 r4440  
    1111
    1212use Apache::TestUtil;
    13 use PS::IPP::IData::Util qw( :standard );
     13use Nebulous::Util qw( :standard );
    1414use SOAP::Lite;
    15 use Test::IData;
     15use Test::Nebulous;
    1616
    1717my $hostport = Apache::Test::config()->{ 'hostport' };
    18 my $idata = SOAP::Lite->new(
    19     proxy   => "http://$hostport/idata",
    20     uri     => "http://pan-starrs.ifa.hawaii.edu/PS/IPP/IData/Server",
     18my $neb = SOAP::Lite->new(
     19    proxy   => "http://$hostport/nebulous",
     20    uri     => "http://pan-starrs.ifa.hawaii.edu/PS/IPP/Nebulous/Server",
    2121);
    2222
    23 Test::IData->setup;
     23Test::Nebulous->setup;
    2424
    2525{
    2626    # key
    27     $idata->create_object( "foo" );
    28     my $uri = $idata->replicate_object( "foo" )->result;
     27    $neb->create_object( "foo" );
     28    my $uri = $neb->replicate_object( "foo" )->result;
    2929
    3030    ok( -e _get_file_path( $uri ), "file exists" );
    … …  
    3333}
    3434
    35 Test::IData->setup;
     35Test::Nebulous->setup;
    3636
    3737{
    3838    # key, $volume
    39     $idata->create_object( "foo" );
    40     my $uri = $idata->replicate_object( "foo", "node01" )->result;
     39    $neb->create_object( "foo" );
     40    my $uri = $neb->replicate_object( "foo", "node01" )->result;
    4141
    4242    ok( -e _get_file_path( $uri ), "file exists" );
    … …  
    4545}
    4646
    47 Test::IData->setup;
     47Test::Nebulous->setup;
    4848
    4949{
    5050    # key, $volume
    51     $idata->create_object( "foo" );
    52     my $uri1 = $idata->replicate_object( "foo", "node01" )->result;
    53     my $uri2 = $idata->replicate_object( "foo", "node02" )->result;
     51    $neb->create_object( "foo" );
     52    my $uri1 = $neb->replicate_object( "foo", "node01" )->result;
     53    my $uri2 = $neb->replicate_object( "foo", "node02" )->result;
    5454
    5555    ok( -e _get_file_path( $uri1 ), "file exists" );
    … …  
    6060}
    6161
    62 Test::IData->setup;
     62Test::Nebulous->setup;
    6363
    6464{
    65     my $response = $idata->replicate_object();
     65    my $response = $neb->replicate_object();
    6666
    6767    like( $response->faultstring, qr/1 - 2 were expected/, "no params" );
    6868}
    6969
    70 Test::IData->setup;
     70Test::Nebulous->setup;
    7171
    7272{
    73     my $response = $idata->replicate_object( 1, 2, 3 );
     73    my $response = $neb->replicate_object( 1, 2, 3 );
    7474
    7575    like( $response->faultstring, qr/1 - 2 were expected/, "too many params" );
    7676}
    7777
    78 Test::IData->setup;
     78Test::Nebulous->setup;
    7979
    8080{
    81     my $response = $idata->replicate_object( "foo" );
     81    my $response = $neb->replicate_object( "foo" );
    8282
    8383    like( $response->faultstring, qr/storage object does not exist/, "storage object does not exist" );
    8484}
    8585
    86 Test::IData->cleanup;
     86Test::Nebulous->cleanup;

  • trunk/Nebulous-Server/t/apache_05_server_lock_object.x

    r2785 r4440  
    1111
    1212use Apache::TestUtil;
    13 use PS::IPP::IData::Util qw( :standard );
     13use Nebulous::Util qw( :standard );
    1414use SOAP::Lite;
    15 use Test::IData;
     15use Test::Nebulous;
    1616
    1717my $hostport = Apache::Test::config()->{ 'hostport' };
    18 my $idata = SOAP::Lite->new(
    19     proxy   => "http://$hostport/idata",
    20     uri     => "http://pan-starrs.ifa.hawaii.edu/PS/IPP/IData/Server",
     18my $neb = SOAP::Lite->new(
     19    proxy   => "http://$hostport/nebulous",
     20    uri     => "http://pan-starrs.ifa.hawaii.edu/PS/IPP/Nebulous/Server",
    2121);
    2222
    23 Test::IData->setup;
     23Test::Nebulous->setup;
    2424
    2525{
    26     $idata->create_object( "foo" );
     26    $neb->create_object( "foo" );
    2727
    28     ok( $idata->lock_object( "foo", "read" )->result, "read lock" );
     28    ok( $neb->lock_object( "foo", "read" )->result, "read lock" );
    2929}
    3030
    31 Test::IData->setup;
     31Test::Nebulous->setup;
    3232
    3333{
    34     $idata->create_object( "foo" );
     34    $neb->create_object( "foo" );
    3535
    36     ok( $idata->lock_object( "foo", "read" )->result, "read lock" );
    37     ok( $idata->lock_object( "foo", "read" )->result, "read lock" );
     36    ok( $neb->lock_object( "foo", "read" )->result, "read lock" );
     37    ok( $neb->lock_object( "foo", "read" )->result, "read lock" );
    3838}
    3939
    40 Test::IData->setup;
     40Test::Nebulous->setup;
    4141
    4242{
    43     $idata->create_object( "foo" );
     43    $neb->create_object( "foo" );
    4444
    45     ok( $idata->lock_object( "foo", "write" )->result, "write lock" );
     45    ok( $neb->lock_object( "foo", "write" )->result, "write lock" );
    4646}
    4747
    48 Test::IData->setup;
     48Test::Nebulous->setup;
    4949
    5050{
    51     my $result = $idata->lock_object( "foo", "read" );
     51    my $result = $neb->lock_object( "foo", "read" );
    5252
    5353    like( $result->faultstring, qr/storage object does not exist/, "storage object does not exist" );
    5454}
    5555
    56 Test::IData->setup;
     56Test::Nebulous->setup;
    5757
    5858{
    59     my $result = $idata->lock_object( "foo", "write" );
     59    my $result = $neb->lock_object( "foo", "write" );
    6060
    6161    like( $result->faultstring, qr/storage object does not exist/, "storage object does not exist" );
    6262}
    6363
    64 Test::IData->setup;
     64Test::Nebulous->setup;
    6565
    6666{
    67     $idata->create_object( "foo" );
     67    $neb->create_object( "foo" );
    6868
    69     $idata->lock_object( "foo", "write" );
    70     my $result = $idata->lock_object( "foo", "write" );
     69    $neb->lock_object( "foo", "write" );
     70    my $result = $neb->lock_object( "foo", "write" );
    7171
    7272    like( $result->faultstring, qr/can not write lock twice/, "can not write lock twice" );
    7373}
    7474
    75 Test::IData->setup;
     75Test::Nebulous->setup;
    7676
    7777{
    78     $idata->create_object( "foo" );
     78    $neb->create_object( "foo" );
    7979
    80     $idata->lock_object( "foo", "read" );
    81     my $result = $idata->lock_object( "foo", "write" );
     80    $neb->lock_object( "foo", "read" );
     81    my $result = $neb->lock_object( "foo", "write" );
    8282
    8383    like( $result->faultstring, qr/can not write lock after read lock/, "can not write lock after read lock" );
    8484}
    8585
    86 Test::IData->setup;
     86Test::Nebulous->setup;
    8787
    8888{
    89     $idata->create_object( "foo" );
     89    $neb->create_object( "foo" );
    9090
    91     $idata->lock_object( "foo", "write" );
    92     my $result = $idata->lock_object( "foo", "read" );
     91    $neb->lock_object( "foo", "write" );
     92    my $result = $neb->lock_object( "foo", "read" );
    9393
    9494    like( $result->faultstring, qr/can not read lock after write lock/, "can not read lock after write lock" );
    9595}
    9696
    97 Test::IData->setup;
     97Test::Nebulous->setup;
    9898
    9999{
    100     my $result = $idata->lock_object();
     100    my $result = $neb->lock_object();
    101101
    102102    like( $result->faultstring, qr/2 were expected/, "no params" );
    103103}
    104104
    105 Test::IData->setup;
     105Test::Nebulous->setup;
    106106
    107107{
    108     my $result = $idata->lock_object( "foo" );
     108    my $result = $neb->lock_object( "foo" );
    109109
    110110    like( $result->faultstring, qr/2 were expected/, "not enough params" );
    111111}
    112112
    113 Test::IData->setup;
     113Test::Nebulous->setup;
    114114
    115115{
    116     my $result = $idata->lock_object( "foo", "both" );
     116    my $result = $neb->lock_object( "foo", "both" );
    117117
    118118    like( $result->faultstring, qr/is read or write/, "not read or write" );
    119119}
    120120
    121 Test::IData->setup;
     121Test::Nebulous->setup;
    122122
    123123{
    124     my $result = $idata->lock_object( "foo", 'read', 3 );
     124    my $result = $neb->lock_object( "foo", 'read', 3 );
    125125
    126126    like( $result->faultstring, qr/2 were expected/, "too many params" );
    127127}
    128128
    129 Test::IData->cleanup;
     129Test::Nebulous->cleanup;
Note: See TracChangeset for help on using the changeset viewer.