Пример #1
0
  public MockCatalogBuilder coverageStore(String name, String filename, String format) {
    String csId = newId();
    WorkspaceInfo ws = workspaces.peekLast();
    NamespaceInfo ns = namespaces.peekLast();

    final CoverageStoreInfo cs = createNiceMock(CoverageStoreInfo.class);
    coverageStores.add(cs);

    initStore(cs, CoverageStoreInfo.class, csId, name, ws);

    File covDir = new File(dataDirRoot, name);
    final File covFile = new File(covDir, filename);
    expect(cs.getURL()).andReturn(DataUtilities.fileToURL(covFile).toString()).anyTimes();
    expect(cs.getType())
        .andAnswer(
            new IAnswer<String>() {
              @Override
              public String answer() throws Throwable {
                return lookupGridFormat(covFile).getName();
              }
            })
        .anyTimes();
    expect(cs.getFormat())
        .andAnswer(
            new IAnswer<AbstractGridFormat>() {
              @Override
              public AbstractGridFormat answer() throws Throwable {
                return lookupGridFormat(covFile);
              }
            })
        .anyTimes();
    expect(cs.getConnectionParameters()).andReturn(new HashMap()).anyTimes();

    expect(catalog.getCoverageStore(csId)).andReturn(cs).anyTimes();
    expect(catalog.getCoverageStoreByName(name)).andReturn(cs).anyTimes();
    expect(catalog.getCoverageStoreByName(ws.getName(), name)).andReturn(cs).anyTimes();
    expect(catalog.getCoverageStoreByName(ws, name)).andReturn(cs).anyTimes();

    cs.accept((CatalogVisitor) anyObject());
    expectLastCall()
        .andAnswer(
            new VisitAnswer() {
              @Override
              protected void doVisit(CatalogVisitor visitor) {
                visitor.visit(cs);
              }
            })
        .anyTimes();

    callback.onStore(name, cs, ws, this);
    replay(cs);
    return this;
  }
Пример #2
0
  public MockCatalogBuilder workspace(String name, String uri) {
    String wsId = newId();
    String nsId = newId();

    final WorkspaceInfo ws = createNiceMock(WorkspaceInfo.class);
    workspaces.add(ws);
    expect(ws.getId()).andReturn(wsId).anyTimes();
    expect(ws.getName()).andReturn(name).anyTimes();
    expect(ws.getMetadata()).andReturn(new MetadataMap()).anyTimes();

    expect(catalog.getWorkspace(wsId)).andReturn(ws).anyTimes();
    expect(catalog.getWorkspaceByName(name)).andReturn(ws).anyTimes();

    final NamespaceInfo ns = createNiceMock(NamespaceInfo.class);
    namespaces.add(ns);

    expect(ns.getId()).andReturn(nsId).anyTimes();
    expect(ns.getName()).andReturn(name).anyTimes();
    expect(ns.getPrefix()).andReturn(name).anyTimes();
    expect(ns.getMetadata()).andReturn(new MetadataMap()).anyTimes();

    expect(catalog.getNamespace(nsId)).andReturn(ns).anyTimes();
    expect(catalog.getNamespaceByPrefix(name)).andReturn(ns).anyTimes();
    expect(catalog.getNamespaceByURI(uri)).andReturn(ns).anyTimes();

    ws.accept((CatalogVisitor) anyObject());
    expectLastCall()
        .andAnswer(
            new VisitAnswer() {
              @Override
              protected void doVisit(CatalogVisitor visitor) {
                visitor.visit(ws);
              }
            })
        .anyTimes();

    ns.accept((CatalogVisitor) anyObject());
    expectLastCall()
        .andAnswer(
            new VisitAnswer() {
              @Override
              protected void doVisit(CatalogVisitor visitor) {
                visitor.visit(ns);
              }
            })
        .anyTimes();

    callback.onWorkspace(name, ws, this);

    replay(ws, ns);
    return this;
  }
Пример #3
0
  public MockCatalogBuilder dataStore(String name) {
    String dsId = newId();
    final WorkspaceInfo ws = workspaces.peekLast();
    final NamespaceInfo ns = namespaces.peekLast();

    final DataStoreInfo ds = createNiceMock(DataStoreInfo.class);
    dataStores.add(ds);

    initStore(ds, DataStoreInfo.class, dsId, name, ws);

    // setup the property data store
    final File propDir = new File(dataDirRoot, name);

    HashMap cxParams = new HashMap();
    cxParams.put(PropertyDataStoreFactory.DIRECTORY.key, propDir);
    cxParams.put(PropertyDataStoreFactory.NAMESPACE.key, ns.getURI());
    expect(ds.getConnectionParameters()).andReturn(cxParams).anyTimes();

    try {
      expect(ds.getDataStore(null))
          .andAnswer(
              (IAnswer)
                  new IAnswer<DataAccess>() {
                    @Override
                    public DataAccess answer() throws Throwable {
                      return new PropertyDataStore(propDir, ns.getURI());
                    }
                  })
          .anyTimes();
    } catch (IOException e) {
    }

    expect(catalog.getDataStore(dsId)).andReturn(ds).anyTimes();
    expect(catalog.getDataStoreByName(name)).andReturn(ds).anyTimes();
    expect(catalog.getDataStoreByName(ws.getName(), name)).andReturn(ds).anyTimes();
    expect(catalog.getDataStoreByName(ws, name)).andReturn(ds).anyTimes();

    ds.accept((CatalogVisitor) anyObject());
    expectLastCall()
        .andAnswer(
            new VisitAnswer() {
              @Override
              protected void doVisit(CatalogVisitor visitor) {
                visitor.visit(ds);
              }
            })
        .anyTimes();

    callback.onStore(name, ds, ws, this);
    replay(ds);
    return this;
  }
Пример #4
0
  <T extends StoreInfo> void initStore(
      T s, Class<T> clazz, String sId, String name, WorkspaceInfo ws) {
    expect(s.getId()).andReturn(sId).anyTimes();
    expect(s.getName()).andReturn(name).anyTimes();
    expect(s.getWorkspace()).andReturn(ws).anyTimes();
    expect(s.getCatalog()).andReturn(catalog).anyTimes();
    expect(s.isEnabled()).andReturn(true).anyTimes();

    expect(catalog.getStore(sId, clazz)).andReturn(s).anyTimes();
    expect(catalog.getStore(sId, StoreInfo.class)).andReturn(s).anyTimes();

    expect(catalog.getStoreByName(name, clazz)).andReturn(s).anyTimes();
    expect(catalog.getStoreByName(name, StoreInfo.class)).andReturn(s).anyTimes();

    expect(catalog.getStoreByName(ws.getName(), name, clazz)).andReturn(s).anyTimes();
    expect(catalog.getStoreByName(ws.getName(), name, StoreInfo.class)).andReturn(s).anyTimes();

    expect(catalog.getStoreByName(ws, name, clazz)).andReturn(s).anyTimes();
    expect(catalog.getStoreByName(ws, name, StoreInfo.class)).andReturn(s).anyTimes();
  }
Пример #5
0
  public MockCatalogBuilder commit() {
    if (!featureTypes.isEmpty() || !coverages.isEmpty()) {
      if (!featureTypes.isEmpty()) {
        DataStoreInfo ds = dataStores.peekLast();

        expect(catalog.getResourcesByStore(ds, FeatureTypeInfo.class))
            .andReturn(featureTypes)
            .anyTimes();
        expect(catalog.getResourcesByStore(ds, ResourceInfo.class))
            .andReturn((List) featureTypes)
            .anyTimes();
        expect(catalog.getFeatureTypesByDataStore(ds)).andReturn(featureTypes).anyTimes();
      }

      if (!coverages.isEmpty()) {
        CoverageStoreInfo cs = coverageStores.peekLast();

        expect(catalog.getResourcesByStore(cs, CoverageInfo.class)).andReturn(coverages).anyTimes();
        expect(catalog.getResourcesByStore(cs, ResourceInfo.class))
            .andReturn((List) coverages)
            .anyTimes();
        expect(catalog.getCoveragesByCoverageStore(cs)).andReturn(coverages).anyTimes();
      }

      // clear out local lists but push up to be included when this workspace is complete
      featureTypesByNamespace.addAll(featureTypes);
      featureTypes = new LinkedList<FeatureTypeInfo>();

      coveragesByNamespace.addAll(coverages);
      coverages = new LinkedList<CoverageInfo>();

    } else if (!dataStores.isEmpty() || !coverageStores.isEmpty()) {
      WorkspaceInfo ws = workspaces.peekLast();
      NamespaceInfo ns = namespaces.peekLast();

      expect(catalog.getStoresByWorkspace(ws.getName(), DataStoreInfo.class))
          .andReturn(dataStores)
          .anyTimes();
      expect(catalog.getStoresByWorkspace(ws, DataStoreInfo.class))
          .andReturn(dataStores)
          .anyTimes();
      expect(catalog.getDataStoresByWorkspace(ws.getName())).andReturn(dataStores).anyTimes();
      expect(catalog.getDataStoresByWorkspace(ws)).andReturn(dataStores).anyTimes();

      expect(catalog.getStoresByWorkspace(ws.getName(), CoverageStoreInfo.class))
          .andReturn(coverageStores)
          .anyTimes();
      expect(catalog.getStoresByWorkspace(ws, CoverageStoreInfo.class))
          .andReturn(coverageStores)
          .anyTimes();
      expect(catalog.getCoverageStoresByWorkspace(ws.getName()))
          .andReturn(coverageStores)
          .anyTimes();
      expect(catalog.getCoverageStoresByWorkspace(ws)).andReturn(coverageStores).anyTimes();

      List<StoreInfo> l = new LinkedList<StoreInfo>(dataStores);
      l.addAll(coverageStores);

      expect(catalog.getStoresByWorkspace(ws.getName(), StoreInfo.class)).andReturn(l).anyTimes();
      expect(catalog.getStoresByWorkspace(ws, StoreInfo.class)).andReturn(l).anyTimes();

      // add all the resources for this workspace
      List<ResourceInfo> m = new LinkedList(featureTypesByNamespace);
      m.addAll(coveragesByNamespace);
      expect(catalog.getResourcesByNamespace(ns, ResourceInfo.class)).andReturn(m).anyTimes();
      // expect(catalog.getResourcesByNamespace(ns.getPrefix(),
      // ResourceInfo.class)).andReturn(m).anyTimes();
      expect(catalog.getResourcesByNamespace(ns, FeatureTypeInfo.class))
          .andReturn(featureTypesByNamespace)
          .anyTimes();
      // expect(catalog.getResourcesByNamespace(ns.getPrefix(), FeatureTypeInfo.class))
      //    .andReturn(featureTypesByNamespace).anyTimes();
      expect(catalog.getResourcesByNamespace(ns, CoverageInfo.class))
          .andReturn(coveragesByNamespace)
          .anyTimes();
      // expect(catalog.getResourcesByNamespace(ns.getPrefix(), CoverageInfo.class))
      //    .andReturn(coveragesByNamespace).anyTimes();

      dataStoresAll.addAll(dataStores);
      dataStores = new LinkedList();

      coverageStoresAll.addAll(coverageStores);
      coverageStores = new LinkedList();

      featureTypesAll.addAll(featureTypesByNamespace);
      featureTypesByNamespace = new LinkedList();

      coveragesAll.addAll(coveragesByNamespace);
      coveragesByNamespace = new LinkedList();
    } else if (!workspaces.isEmpty()) {

      // all the resources
      List<ResourceInfo> l = new LinkedList<ResourceInfo>(featureTypesAll);
      l.addAll(coveragesAll);
      expect(catalog.getResources(ResourceInfo.class)).andReturn(l).anyTimes();
      expect(catalog.getResources(FeatureTypeInfo.class)).andReturn(featureTypesAll).anyTimes();
      expect(catalog.getResources(CoverageInfo.class)).andReturn(coverages).anyTimes();
      expect(catalog.getFeatureTypes()).andReturn(featureTypesAll).anyTimes();
      expect(catalog.getCoverages()).andReturn(coveragesAll).anyTimes();

      // add all the stores
      List<StoreInfo> m = new LinkedList<StoreInfo>(dataStoresAll);
      m.addAll(coverageStoresAll);
      expect(catalog.getStores(StoreInfo.class)).andReturn(m).anyTimes();
      expect(catalog.getStores(DataStoreInfo.class)).andReturn(dataStoresAll).anyTimes();
      expect(catalog.getStores(CoverageStoreInfo.class)).andReturn(coverageStoresAll).anyTimes();

      // add all the styles
      expect(catalog.getStyles()).andReturn(styles).anyTimes();

      // add all the layer groups
      expect(catalog.getLayerGroups()).andReturn(layerGroups).anyTimes();

      // add all the workspaces/namespaces
      expect(catalog.getWorkspaces()).andReturn(workspaces).anyTimes();
      expect(catalog.getNamespaces()).andReturn(namespaces).anyTimes();

      // default workspace/namespace
      expect(catalog.getDefaultWorkspace()).andReturn(workspaces.peekFirst()).anyTimes();
      expect(catalog.getDefaultNamespace()).andReturn(namespaces.peekFirst()).anyTimes();

      replay(catalog);

      featureTypesAll = new LinkedList();
      coveragesAll = new LinkedList();
      dataStoresAll = new LinkedList();
      coverageStoresAll = new LinkedList();
      styles = new LinkedList();
      workspaces = new LinkedList();
      namespaces = new LinkedList();
    }

    return this;
  }