root/trunk/cartwheel-clients/canal/test/testAPI.py

##############################################################################
#
# This file is part of the cartwheel-clients source distribution.
#
# cartwheel-clients is part of the Cartwheel Bioinformatics Toolkit:
#      http://cartwheel.caltech.edu/.
#
# Contact author: C. Titus Brown, titus@caltech.edu.
#
# This program and all associated source code files are Copyright (C) 2001,
# 2002 the California Institute of Technology, Pasadena, CA, 91125 USA.
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 2.1 of the License, or (at your option) any later version.
# (see doc/LICENSE.txt).
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
#
##############################################################################

"""
The set of tests that a client library has to pass in order to meet the
minimal canal client spec.
"""

#
# run_tests
#

def run_tests(api):
    """
    'run_tests' takes a module or object that implements the Cartwheel
    canal client API and tests it.  All API modules should pass these tests.
    """

    #
    # First test the read-only interface for getting lab/etc information:
    #

    assert not api.is_authenticated()

    # authenticate: user/pass
    api.authenticate('admin', 'admin')

    assert api.is_authenticated()

    #
    # Print out some info
    #
    print 'server:', api.get_server_name(), '/', api.get_server_info()

    #
    # Test the ro interface: run through the labs.
    #

    labs = api.get_lab_list()
    
    if not labs:
        raise Exception("no available labs to look at! check access perms")

    lab = api.get_current_lab()
    api.set_current_lab(lab.id)
    print 'current lab:', lab.id

    for (id, name) in labs:
        lab = api.get_lab(id)
        print 'lab:', lab.get_name()

        folders = lab.get_folder_list()
        if folders:
            # run through the sub-folders:
            for (id, name) in folders:
                folder = lab.get_folder(id)
                print 'folder:', folder.get_name()

                # check out the sub-folders, if any:
                folders2 = folder.get_folder_list()
                if folders2:
                    id = folders2[0][0]
                    folder2 = folder.get_folder(id)
                    print 'subfolder:', folder.get_name()

                # check out the sequences, if any:
                sequences = folder.get_sequence_list()
                if sequences:
                    id = sequences[0][0]
                    sequence = folder.get_sequence(id)
                    print 'sequence:', sequence.get_name()

                # check out the analyses, if any:
                analysis_groups = folder.get_analysis_group_list()
                if analysis_groups:
                    id = analysis_groups[0][0]
                    group = folder.get_analysis_group(id)
                    group.get_sister_data(1)
                    print 'analysis group:', group.get_name()

                    analyses = group.get_analyses()
                    for analysis in analyses:
                        print 'analysis:', analysis.get_name(), \
                              analysis.get_type()
                        analysis.get_sister_data()

                if sequences and analysis_groups:
                    break               # keep looping *until* checked both

    #####

    #
    # Now test out the write interface, for creating analysis groups etc.
    #

    lab = api.get_current_lab()

    for db in lab.get_blast_databases():
        print "BLAST DB:", db.get_printable_name()

    # retain db for later use...

    print 'creating node folder'
    top_folder = lab.create_node_folder('auto test - NODE')
    print 'created node folder -- %s (%s)' % (top_folder.get_name(),
                                              top_folder.get_type())

    leaf_folder = top_folder.create_leaf_folder('auto test - SUB LEAF')
    print 'created leaf folder 1 -- %s (%s)' % (leaf_folder.get_name(),
                                                leaf_folder.get_type())

    folder = lab.create_leaf_folder('auto test - TOP LEAF')
    print 'created leaf folder 2 -- %s (%s)' % (folder.get_name(),
                                                folder.get_type())

    print 'creating sequences in folder'
    seq1 = folder.add_sequence("seq1", "ATGCCGGGNAGGAGATGGT", "DNA")
    seq2 = folder.add_sequence("seq2", "GAGAGNAGAGAGAGATATATAGC", "DNA")
    seq3 = folder.add_sequence("seq3", "GGGCCAGCCCCGAGAGATATATAGC", "DNA")

    print 'creating a few analysis groups...'
    single = folder.add_single_analysis_group("TEST single", seq1)
    pair = folder.add_pair_analysis_group("TEST pair", seq1, seq2)

    # test some of the API functions...
    single.get_sequence()
    pair.get_top_sequence()
    pair.get_top_group()
    pair.get_bot_sequence()
    pair.get_bot_group()

    analysis = single.add_blast_against_database("my blast db", 'blastn', db)
    print 'added analysis %s (%s)' % (analysis.get_name(), analysis.get_type())

    analysis = single.add_blast_against_sequence("my seq blast", 'blastn',
                                                 pair.get_bot_sequence())
    print 'added analysis %s (%s)' % (analysis.get_name(), analysis.get_type())
    

    analysis = single.add_hmmgene_analysis("my hmmgene anal")
    print 'added analysis %s (%s)' % (analysis.get_name(), analysis.get_type())
    
    analysis = single.add_genscan_analysis("my genscan anal")
    print 'added analysis %s (%s)' % (analysis.get_name(), analysis.get_type())
    
    analysis = single.add_geneid_analysis("my geneid anal")
    print 'added analysis %s (%s)' % (analysis.get_name(), analysis.get_type())

    analysis = single.add_deepblast_analysis("my deepblast anal")
    print 'added analysis %s (%s)' % (analysis.get_name(), analysis.get_type())

    analysis = single.add_simple_motif_search("my motif search",
                                              "ATG\nAGG\nACG\n", '')
    print 'added analysis %s (%s)' % (analysis.get_name(), analysis.get_type())

    analysis = single.add_simple_features("my features",
                                          "10 20 hello there\n")
    print 'added analysis %s (%s)' % (analysis.get_name(), analysis.get_type())

    analysis = single.add_IFF_data("my IFF data", "", "")
    print 'added analysis %s (%s)' % (analysis.get_name(), analysis.get_type())

    analysis = single.add_GFF_data("my GFF data", "", "")
    print 'added analysis %s (%s)' % (analysis.get_name(), analysis.get_type())
    
    a1 = pair.add_blast_analysis('my pair blast', 'blastn')
    print 'added analysis %s (%s)' % (a1.get_name(), a1.get_type())
    
    a2 = pair.add_seqcomp_analysis('my seqcomp', 20, .7)
    print 'added analysis %s (%s)' % (a2.get_name(), a2.get_type())

    a3 = pair.add_blastz_analysis('my blastz')

    a4 = pair.add_lagan_vista_analysis('my laganvista', 100, .6, forward=True)

    analysis.get_sister_data()
    a1.get_sister_data()

    print 'testing three-way analysis.'
    triple = folder.add_triple_analysis_group("TEST triple",
                                              seq1, seq2, seq3,
                                              0, -1, 0, -1, 0, -1,
                                              20, .7)

    top = triple.get_top_group()
    mid = triple.get_mid_group()
    bot = triple.get_bot_group()

    threshold = triple.get_threshold()
    windowsize = triple.get_windowsize()

    (ab_seqcomp,start_top,end_top,start_bot,end_bot) = triple.get_ab_seqcomp()
    (bc_seqcomp,start_top,end_top,start_bot,end_bot) = triple.get_bc_seqcomp()
    (ac_seqcomp,start_top,end_top,start_bot,end_bot) = triple.get_ac_seqcomp()

    print 'cleaning up...'
    single.delete_analysis(analysis)
    pair.delete_analysis(a1)
    pair.delete_analysis(a2)

    folder.delete_analysis_group(single)
    folder.delete_analysis_group(pair)
    folder.delete_analysis_group(triple)

    folder.delete_sequence(seq1)
    folder.delete_sequence(seq2)
    folder.delete_sequence(seq3)
    
    top_folder.delete_folder(leaf_folder)
    lab.delete_folder(top_folder)
    lab.delete_folder(folder)

    print 'logging off'
    api.logout()
    assert not api.is_authenticated()

    print 'All tests PASSED.'

    return 1