Mercurialplover / file revision
summary | shortlog | changelog | graph | tags | branches | files | changeset | file | revisions | annotate | diff | raw
tests/plover/test-packageset.c
author J. Ali Harlow <ali@juiblex.co.uk>
Sat Jul 16 11:07:18 2016 +0100 (2016-07-16)
changeset 61 31fb35727621
parent 55 8c80282a3888
permissions -rw-r--r--
Support parallel installations. The idea is that for CAD screener, we want
to be able to install this on the same machine as a standard AVOT setup
(most notably for John's laptop). To allow for the possibility of a second
application that might have the same requirements, we add the concept of
vendor-specific distributions. Thus we can have one distribution for CAD
screener and one for The Next Big Thing. It doesn't seem trivial to have
both CAD screener and AVOT under the same vendor tag so we'll have to have
AVOT under "City Occupational" and CAD screener under "City Occupational Ltd"
or some such kludge.

Most of this is done although we are very short of test cases (in particular
we don't test that it's actually possible to install CAD screener in parallel
with AVOT or to update either of them once installed, which is fundamental).

We also have a lot of baggage left over, including an intercept of razor_set.
The problem that this was introduced to debug has been fixed but it looks
like there are a number of memory leaks which it might be useful to help
track down so it has been left in place for now.

There is still a lot of confusion in plover between path-based and URI-based
API. We should review the API, decide what we want and have a general clear up.

There is also confusion as to the purpose of RAZOR_ROOT (and meaning; path or
URI). This is not used at all in librazor (although it is used in razor.exe).
Ideally we shouldn't use it in plover or plover-gtk either although again, we
might want to support it or an equivalent in (some of) the various executables.

Work that would still to nice to do for CAD screener:

- uninstall (ideally as an installed program that hooks into Add/Remove programs
but even re-running the installer would be acceptable).
- xz support (smaller packages).
- repomd.xml and xml:base (would be needed for an Internet installer).
- graphical installer. 
     1 /*

     2  * Copyright (C) 2016  J. Ali Harlow <ali@juiblex.co.uk>

     3  *

     4  * This program is free software; you can redistribute it and/or modify

     5  * it under the terms of the GNU General Public License as published by

     6  * the Free Software Foundation; either version 2 of the License, or

     7  * (at your option) any later version.

     8  *

     9  * This program is distributed in the hope that it will be useful,

    10  * but WITHOUT ANY WARRANTY; without even the implied warranty of

    11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    12  * GNU General Public License for more details.

    13  *

    14  * You should have received a copy of the GNU General Public License along

    15  * with this program; if not, write to the Free Software Foundation, Inc.,

    16  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

    17  */

    18 

    19 #include <stdlib.h>

    20 #include <glib.h>

    21 #include <razor.h>

    22 #include <plover/plover.h>

    23 #include <plover/packageset.h>

    24 

    25 const char *yum_packages[]={

    26     "zsh","zsh2","zip","zap","filesystem","zappy","zappy-tools","zappy2",

    27     "unsatisfiable","uninstallable","badpostun"

    28 };

    29 

    30 const char *zappy_packages[]={

    31     "zap","zappy","zappy-tools","zappy2"

    32 };

    33 

    34 static struct razor_set *get_dummy_set(void)

    35 {

    36     struct razor_importer *importer;

    37     importer=razor_importer_create();

    38     g_assert(importer != NULL);

    39     razor_importer_begin_package(importer,"dummy","1-1","noarch");

    40     razor_importer_add_details(importer,"Dummy package",

    41       "A dummy package for testing","http://www.juiblex.co.uk/beach","GPL");

    42     razor_importer_add_property(importer,"dummy",

    43       RAZOR_PROPERTY_PROVIDES|RAZOR_PROPERTY_EQUAL,"1-1");

    44     razor_importer_finish_package(importer);

    45     return razor_importer_finish(importer);

    46 }

    47 

    48 static int verify_empty_set_compar(gconstpointer a,gconstpointer b)

    49 {

    50     return 0;

    51 }

    52 

    53 static void verify_empty_set(PloverPackageSet *package_set)

    54 {

    55     struct razor_set *set;

    56     struct razor_package *pkg;

    57     struct razor_package_iterator *iter;

    58     struct comps *comps;

    59     PloverPackage *package;

    60     GError *err=NULL;

    61     const char *prefix;

    62     gchar *default_prefix;

    63     g_assert(!plover_package_set_get_packages(package_set));

    64     set=get_dummy_set();

    65     g_assert(set != NULL);

    66     iter=razor_package_iterator_create(set);

    67     g_assert(iter != NULL);

    68     g_assert(razor_package_iterator_next(iter,&pkg,RAZOR_DETAIL_LAST));

    69     g_assert(!plover_package_set_lookup(package_set,pkg));

    70     razor_package_iterator_destroy(iter);

    71     g_assert(!plover_package_set_find_custom(package_set,NULL,

    72       verify_empty_set_compar));

    73     package=plover_package_new(set,pkg);

    74     g_assert(package != NULL);

    75     g_assert(!plover_package_set_find_matching(package_set,package));

    76     g_object_unref(package);

    77     razor_set_unref(set);

    78     g_assert(!plover_package_set_get_no_details(package_set));

    79     prefix=plover_package_set_guess_prefix(package_set,&err);

    80     if (!prefix && err)

    81 	g_error("plover_package_set_guess_prefix: %s",err->message);

    82     g_assert(err == NULL);

    83     comps=plover_comps_new();

    84     plover_comps_set_vendor(comps,"Acme Corporation");

    85     default_prefix=plover_comps_get_default_prefix(comps);

    86     plover_comps_free(comps);

    87     g_assert_cmpstr(prefix,==,default_prefix);

    88     g_free(default_prefix);

    89 }

    90 

    91 static void test_unopened(void)

    92 {

    93     PloverPackageSet *package_set;

    94     package_set=plover_package_set_new();

    95     g_assert(PLOVER_IS_PACKAGE_SET(package_set));

    96     g_assert(!plover_package_set_get_header_version(package_set));

    97     g_assert(!plover_package_set_set_header_version(package_set,1));

    98     g_assert(!plover_package_set_get_install_root(package_set));

    99     g_assert(!plover_package_set_get_exclusive(package_set));

   100     g_assert(!plover_package_set_get_razor(package_set));

   101     verify_empty_set(package_set);

   102     plover_package_set_close(package_set);

   103     g_object_unref(package_set);

   104 }

   105 

   106 static int package_name_compar(gconstpointer a,gconstpointer b)

   107 {

   108     PloverPackage *package=PLOVER_PACKAGE(a);

   109     const char *name=b;

   110     return strcmp(plover_package_get_name(package),name);

   111 }

   112 

   113 static void verify_package_set(PloverPackageSet *package_set,int n_packages,

   114   const char **package_names,const char *prefix)

   115 {

   116     int i,ver;

   117     struct razor_importer *importer;

   118     struct razor_set *set;

   119     struct razor_package *pkg;

   120     struct razor_package_iterator *iter;

   121     PloverPackage *package,*package0;

   122     GError *err=NULL;

   123     const char *guessed_prefix;

   124     GSList *packages,*lnk2;

   125     GList *expected=NULL,*lnk;

   126     ver=plover_package_set_get_header_version(package_set);

   127     g_assert_cmpint(ver,==,RAZOR_HEADER_VERSION);

   128     g_assert(plover_package_set_set_header_version(package_set,

   129       RAZOR_HEADER_VERSION_MIN));

   130     g_assert(plover_package_set_set_header_version(package_set,ver));

   131     g_assert(!plover_package_set_get_exclusive(package_set));

   132     set=plover_package_set_get_razor(package_set);

   133     g_assert(set != NULL);

   134     for(i=0;i<n_packages;i++)

   135 	expected=g_list_prepend(expected,

   136 	  (gpointer)g_intern_string(package_names[i]));

   137     packages=plover_package_set_get_packages(package_set);

   138     package0=NULL;

   139     for(lnk2=packages;lnk2;lnk2=lnk2->next)

   140     {

   141 	package=PLOVER_PACKAGE(lnk2->data);

   142 	if (!strcmp(plover_package_get_name(package),package_names[0]))

   143 	    package0=package;

   144 	lnk=g_list_find(expected,

   145 	  g_intern_string(plover_package_get_name(package)));

   146 	if (!lnk)

   147 	    g_warning("Unexpected package in set: %s",

   148 	      plover_package_get_name(package));

   149 	else

   150 	    expected=g_list_delete_link(expected,lnk);

   151     }

   152     if (expected)

   153 	g_warning("%d missing package%s in set, including %s",

   154 	  g_list_length(expected),g_list_length(expected)==1?"":"s",

   155 	  expected->data);

   156     pkg=plover_package_get_razor_package(package0);

   157     g_assert(plover_package_set_lookup(package_set,pkg)==package0);

   158     g_assert(plover_package_set_find_custom(package_set,package_names[0],

   159       package_name_compar)==package0);

   160     g_assert(plover_package_set_find_matching(package_set,package0)==package0);

   161     g_assert(!plover_package_set_get_no_details(package_set));

   162     guessed_prefix=plover_package_set_guess_prefix(package_set,&err);

   163     if (!guessed_prefix && err)

   164 	g_error("plover_package_set_guess_prefix: %s",err->message);

   165     g_assert(err == NULL);

   166     g_assert_cmpstr(guessed_prefix,==,prefix);

   167 }

   168 

   169 static void verify_zappy_set(PloverPackageSet *package_set)

   170 {

   171     char *root_uri;

   172     verify_package_set(package_set,G_N_ELEMENTS(zappy_packages),zappy_packages,

   173       NULL);

   174     root_uri=razor_path_to_uri("../razor-test-dir");

   175     g_assert_cmpstr(plover_package_set_get_install_root(package_set),==,

   176       root_uri);

   177     free(root_uri);

   178 }

   179 

   180 static void test_open(void)

   181 {

   182     char *root_uri;

   183     PloverPackageSet *package_set;

   184     GError *err=NULL;

   185     package_set=plover_package_set_new();

   186     g_assert(PLOVER_IS_PACKAGE_SET(package_set));

   187     root_uri=razor_path_to_uri("../razor-test-dir");

   188     if (!plover_package_set_open(package_set,root_uri,FALSE,&err))

   189     {

   190 	g_assert(err && err->message);

   191 	g_error("../razor-test-dir: %s",err->message);

   192     }

   193     free(root_uri);

   194     g_assert(!err);

   195     verify_zappy_set(package_set);

   196     plover_package_set_close(package_set);

   197     g_object_unref(package_set);

   198 }

   199 

   200 static void test_update(void)

   201 {

   202     int ver;

   203     struct razor_importer *importer;

   204     struct razor_set *set,*dummy_set;

   205     struct razor_package *pkg;

   206     struct razor_package_iterator *iter;

   207     struct razor_atomic *atomic;

   208     struct comps *comps;

   209     PloverPackageSet *package_set;

   210     PloverPackage *package;

   211     GError *err=NULL;

   212     const char *prefix;

   213     char root[]="razor-test-dir-XXXXXX";

   214     char *root_uri;

   215     gchar *default_prefix;

   216     GSList *packages;

   217     package_set=plover_package_set_new();

   218     g_assert(PLOVER_IS_PACKAGE_SET(package_set));

   219     g_assert(mkdtemp(root));

   220     root_uri=razor_path_to_uri(root);

   221     if (!plover_package_set_open(package_set,root_uri,TRUE,&err))

   222     {

   223 	g_assert(err && err->message);

   224 	g_error("%s: %s",root,err->message);

   225     }

   226     g_assert(!err);

   227     ver=plover_package_set_get_header_version(package_set);

   228     g_assert_cmpint(ver,==,RAZOR_HEADER_VERSION);

   229     g_assert(plover_package_set_set_header_version(package_set,

   230       RAZOR_HEADER_VERSION_MIN));

   231     g_assert(plover_package_set_set_header_version(package_set,ver));

   232     g_assert_cmpstr(plover_package_set_get_install_root(package_set),==,

   233       root_uri);

   234     free(root_uri);

   235     g_assert(plover_package_set_get_exclusive(package_set));

   236     set=plover_package_set_get_razor(package_set);

   237     g_assert(set != NULL);

   238     verify_empty_set(package_set);

   239     dummy_set=get_dummy_set();

   240     atomic=razor_atomic_open("packageset-update");

   241     if (!plover_package_set_update(package_set,dummy_set,atomic))

   242 	g_error("plover_package_set_update: %s",

   243 	  razor_atomic_get_error_msg(atomic));

   244     if (razor_atomic_commit(atomic))

   245 	g_error("plover_package_set_update: commit: %s",

   246 	  razor_atomic_get_error_msg(atomic));

   247     razor_atomic_destroy(atomic);

   248     razor_set_unref(dummy_set);

   249     packages=plover_package_set_get_packages(package_set);

   250     g_assert_cmpint(g_slist_length(packages),==,1);

   251     package=PLOVER_PACKAGE(packages->data);

   252     g_assert_cmpstr(plover_package_get_name(package),==,"dummy");

   253     pkg=plover_package_get_razor_package(package);

   254     g_assert(plover_package_set_lookup(package_set,pkg)==package);

   255     g_assert(plover_package_set_find_custom(package_set,"dummy",

   256       package_name_compar)==package);

   257     g_assert(plover_package_set_find_matching(package_set,package)==package);

   258     g_assert(!plover_package_set_get_no_details(package_set));

   259     prefix=plover_package_set_guess_prefix(package_set,&err);

   260     if (!prefix && err)

   261 	g_error("plover_package_set_guess_prefix: %s",err->message);

   262     g_assert(err == NULL);

   263     comps=plover_comps_new();

   264     plover_comps_set_vendor(comps,"Acme Corporation");

   265     default_prefix=plover_comps_get_default_prefix(comps);

   266     plover_comps_free(comps);

   267     g_assert_cmpstr(prefix,==,default_prefix);

   268     g_free(default_prefix);

   269     plover_package_set_close(package_set);

   270     g_object_unref(package_set);

   271 }

   272 

   273 static void test_from_installed(void)

   274 {

   275     PloverPackageSet *package_set;

   276     PloverPackage *package;

   277     GError *err=NULL;

   278     char *root_uri;

   279     root_uri=razor_path_to_uri("../razor-test-dir");

   280     package_set=plover_package_set_new_from_installed(root_uri,&err);

   281     free(root_uri);

   282     if (!package_set && err)

   283 	g_error("../razor-test-dir: %s",err->message);

   284     g_assert(PLOVER_IS_PACKAGE_SET(package_set));

   285     g_assert(!err);

   286     verify_zappy_set(package_set);

   287     plover_package_set_close(package_set);

   288     g_object_unref(package_set);

   289 }

   290 

   291 static void test_from_razor(void)

   292 {

   293     struct razor_set *set;

   294     PloverPackageSet *package_set;

   295     PloverPackage *package;

   296     set=razor_set_create_without_root();

   297     package_set=plover_package_set_new_from_razor(set);

   298     g_assert(PLOVER_IS_PACKAGE_SET(package_set));

   299     verify_empty_set(package_set);

   300     plover_package_set_close(package_set);

   301     g_object_unref(package_set);

   302     razor_set_unref(set);

   303 }

   304 

   305 static void verify_yum_set(PloverPackageSet *package_set,const char *prefix)

   306 {

   307     verify_package_set(package_set,G_N_ELEMENTS(yum_packages),yum_packages,

   308       prefix);

   309     g_assert(!plover_package_set_get_install_root(package_set));

   310 }

   311 

   312 static void test_from_repository(void)

   313 {

   314     PloverRepository *repository;

   315     PloverPackageSet *package_set;

   316     PloverPackage *package;

   317     GError *err=NULL;

   318     repository=plover_repository_new_from_yum("../yum-repo-test-dir",&err);

   319     if (!repository && err)

   320 	g_error("../yum-repo-test-dir: %s",err->message);

   321     g_assert(PLOVER_IS_REPOSITORY(repository));

   322     g_assert(!err);

   323     package_set=plover_package_set_new_from_repository(repository,NULL,&err);

   324     if (!package_set && err)

   325 	g_error("../yum-repo-test-dir: %s",err->message);

   326     g_assert(PLOVER_IS_PACKAGE_SET(package_set));

   327     g_assert(!err);

   328     g_object_unref(repository);

   329     verify_yum_set(package_set,NULL);

   330     plover_package_set_close(package_set);

   331     g_object_unref(package_set);

   332 }

   333 

   334 static void test_from_yum(void)

   335 {

   336     struct razor_relocations *relocations;

   337     PloverPackageSet *package_set;

   338     PloverPackage *package;

   339     GError *err=NULL;

   340     relocations=razor_relocations_create();

   341     razor_relocations_add(relocations,"/usr","/test");

   342     package_set=plover_package_set_new_from_yum("../yum-repo-test-dir",

   343       relocations,&err);

   344     if (!package_set && err)

   345 	g_error("../yum-repo-test-dir: %s",err->message);

   346     g_assert(PLOVER_IS_PACKAGE_SET(package_set));

   347     g_assert(!err);

   348     razor_relocations_destroy(relocations);

   349     verify_yum_set(package_set,"/test");

   350     plover_package_set_close(package_set);

   351     g_object_unref(package_set);

   352 }

   353 

   354 static void test_from_rpms(void)

   355 {

   356     int i;

   357     PloverPackageSet *package_set;

   358     PloverPackage *package;

   359     GError *err=NULL;

   360     gchar **filenames;

   361     filenames=g_new(char *,G_N_ELEMENTS(yum_packages)+1);

   362     for(i=0;i<G_N_ELEMENTS(yum_packages);i++)

   363 	filenames[i]=g_strconcat("../yum-repo-test-dir/Packages/",

   364 	  yum_packages[i],"-1-1.noarch.rpm",NULL);

   365     filenames[i]=NULL;

   366     package_set=plover_package_set_new_from_rpms((const char **)filenames,&err);

   367     if (!package_set && err)

   368 	g_error("../yum-repo-test-dir: %s",err->message);

   369     g_assert(PLOVER_IS_PACKAGE_SET(package_set));

   370     g_assert(!err);

   371     g_strfreev(filenames);

   372     verify_yum_set(package_set,NULL);

   373     plover_package_set_close(package_set);

   374     g_object_unref(package_set);

   375 }

   376 

   377 int main(int argc,char **argv)

   378 {

   379     g_test_init(&argc,&argv,NULL);

   380     g_test_bug_base("mailto:ali@juiblex.co.uk");

   381     g_test_add_func("/packageset/unopened",test_unopened);

   382     g_test_add_func("/packageset/open",test_open);

   383     g_test_add_func("/packageset/update",test_update);

   384     g_test_add_func("/packageset/from-installed",test_from_installed);

   385     g_test_add_func("/packageset/from-razor",test_from_razor);

   386     g_test_add_func("/packageset/from-repository",test_from_repository);

   387     g_test_add_func("/packageset/from-yum",test_from_yum);

   388     g_test_add_func("/packageset/from-rpms",test_from_rpms);

   389     return g_test_run();

   390 }
plover